/* dhclient.c

   DHCP Client. */

/*
 * Copyright (c) 2004-2011 by Internet Systems Consortium, Inc. ("ISC")
 * Copyright (c) 1995-2003 by Internet Software Consortium
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
 * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 *   Internet Systems Consortium, Inc.
 *   950 Charter Street
 *   Redwood City, CA 94063
 *   <info@isc.org>
 *   https://www.isc.org/
 *
 * This code is based on the original client state machine that was
 * written by Elliot Poger.  The code has been extensively hacked on
 * by Ted Lemon since then, so any mistakes you find are probably his
 * fault and not Elliot's.
 */

#include "dhcpd.h"
#include <syslog.h>
#include <signal.h>
#include <errno.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <limits.h>

TIME default_lease_time = 43200; /* 12 hours... */
TIME max_lease_time = 86400; /* 24 hours... */

const char *path_dhclient_conf = _PATH_DHCLIENT_CONF;
const char *path_dhclient_db = NULL;
const char *path_dhclient_pid = NULL;
static char path_dhclient_script_array[] = _PATH_DHCLIENT_SCRIPT;
char *path_dhclient_script = path_dhclient_script_array;

/* False (default) => we write and use a pid file */
isc_boolean_t no_pid_file = ISC_FALSE;

int dhcp_max_agent_option_packet_length = 0;

int interfaces_requested = 0;

struct iaddr iaddr_broadcast = { 4, { 255, 255, 255, 255 } };
struct iaddr iaddr_any = { 4, { 0, 0, 0, 0 } };
struct in_addr inaddr_any;
struct sockaddr_in sockaddr_broadcast;
struct in_addr giaddr;
struct data_string default_duid;

/* ASSERT_STATE() does nothing now; it used to be
   assert (state_is == state_shouldbe). */
#define ASSERT_STATE(state_is, state_shouldbe) {}

static const char copyright[] = 
"Copyright 2004-2011 Internet Systems Consortium.";
static const char arr [] = "All rights reserved.";
static const char message [] = "Internet Systems Consortium DHCP Client";
static const char url [] = 
"For info, please visit https://www.isc.org/software/dhcp/";

u_int16_t local_port = 0;
u_int16_t remote_port = 0;
int no_daemon = 0;
struct string_list *client_env = NULL;
int client_env_count = 0;
int onetry = 0;
int quiet = 1;
int nowait = 0;
int stateless = 0;
int wanted_ia_na = -1;		/* the absolute value is the real one. */
int wanted_ia_ta = 0;
int wanted_ia_pd = 0;
char *mockup_relay = NULL;

void run_stateless(int exit_mode);

static void usage(void);

static isc_result_t write_duid(struct data_string *duid);
static void add_reject(struct packet *packet);

static int check_domain_name(const char *ptr, size_t len, int dots);
static int check_domain_name_list(const char *ptr, size_t len, int dots);
static int check_option_values(struct universe *universe, unsigned int opt,
    const char *ptr, size_t len);

static int gFifoFd = -1; //TODO LiDong add.

extern int get_current_clocktime(struct timeval* tv, struct timezone *tz);
extern char* hw_generate_option60(char* value, const char* userid, const char* password, int enterprise, long int xid);

int
main(int argc, char **argv) {
    int fd;
    int i;
    struct interface_info *ip;
    struct client_state *client;
    unsigned seed;
    char *server = NULL;
    isc_result_t status;
    int exit_mode = 0;
    int release_mode = 0;
    struct timeval tv;
    omapi_object_t *listener;
    isc_result_t result;
    int persist = 0;
    int no_dhclient_conf = 0;
    int no_dhclient_db = 0;
    int no_dhclient_pid = 0;
    int no_dhclient_script = 0;
#ifdef DHCPv6
    int local_family_set = 0;
#endif /* DHCPv6 */
    char *s;


    /* Initialize client globals. */
    memset(&default_duid, 0, sizeof(default_duid));

    /* Make sure that file descriptors 0 (stdin), 1, (stdout), and
       2 (stderr) are open. To do this, we assume that when we
       open a file the lowest available file descriptor is used. */
    fd = open("/dev/null", O_RDWR);
    if (fd == 0)
        fd = open("/dev/null", O_RDWR);
    if (fd == 1)
        fd = open("/dev/null", O_RDWR);
    if (fd == 2)
        log_perror = 0; /* No sense logging to /dev/null. */
    else if (fd != -1)
        close(fd);

    openlog("dhclient", LOG_NDELAY, LOG_DAEMON);

#if !(defined(DEBUG) || defined(__CYGWIN32__))
    setlogmask(LOG_UPTO(LOG_INFO));
#endif

    /*
     * Set up the signal handlers, currently we only
     * have one to ignore sigpipe.
     */
    if (dhcp_handle_signal(SIGPIPE, SIG_IGN) != ISC_R_SUCCESS) {
        log_fatal("Can't set up signal handler");
    }

    /* Set up the OMAPI. */
    status = omapi_init();
    if (status != ISC_R_SUCCESS)
        log_fatal("Can't initialize OMAPI: %s",
            isc_result_totext(status));

    /* Set up the OMAPI wrappers for various server database internal
       objects. */
    dhcp_common_objects_setup();

    dhcp_interface_discovery_hook = dhclient_interface_discovery_hook;
    dhcp_interface_shutdown_hook = dhclient_interface_shutdown_hook;
    dhcp_interface_startup_hook = dhclient_interface_startup_hook;

    for (i = 1; i < argc; i++) {
        if (!strcmp(argv[i], "-r")) {
            release_mode = 1;
            no_daemon = 1;
#ifdef DHCPv6
        } else if (!strcmp(argv[i], "-4")) {
            if (local_family_set && local_family != AF_INET)
                log_fatal("Client can only do v4 or v6, not "
                    "both.");
            local_family_set = 1;
            local_family = AF_INET;
        } else if (!strcmp(argv[i], "-6")) {
            if (local_family_set && local_family != AF_INET6)
                log_fatal("Client can only do v4 or v6, not "
                    "both.");
            local_family_set = 1;
            local_family = AF_INET6;
#endif /* DHCPv6 */
        } else if (!strcmp(argv[i], "-x")) { /* eXit, no release */
            release_mode = 0;
            no_daemon = 0;
            exit_mode = 1;
        } else if (!strcmp(argv[i], "-p")) {
            if (++i == argc)
                usage();
            local_port = validate_port(argv[i]);
            log_debug("binding to user-specified port %d",
                ntohs(local_port));
        } else if (!strcmp(argv[i], "-d")) {
            no_daemon = 1;
            quiet = 0;
        } else if (!strcmp(argv[i], "-pf")) {
            if (++i == argc)
                usage();
            path_dhclient_pid = argv[i];
            no_dhclient_pid = 1;
        } else if (!strcmp(argv[i], "--no-pid")) {
            no_pid_file = ISC_TRUE;
        } else if (!strcmp(argv[i], "-cf")) {
            if (++i == argc)
                usage();
            path_dhclient_conf = argv[i];
            no_dhclient_conf = 1;
        } else if (!strcmp(argv[i], "-lf")) {
            if (++i == argc)
                usage();
            path_dhclient_db = argv[i];
            no_dhclient_db = 1;
        } else if (!strcmp(argv[i], "-sf")) {
            if (++i == argc)
                usage();
            path_dhclient_script = argv[i];
            no_dhclient_script = 1;
        } else if (!strcmp(argv[i], "-1")) {
            onetry = 1;
        } else if (!strcmp(argv[i], "-q")) {
            quiet = 1;
        } else if (!strcmp(argv[i], "-s")) {
            if (++i == argc)
                usage();
            server = argv[i];
        } else if (!strcmp(argv[i], "-g")) {
            if (++i == argc)
                usage();
            mockup_relay = argv[i];
        } else if (!strcmp(argv[i], "-nw")) {
            nowait = 1;
        } else if (!strcmp(argv[i], "-n")) {
            /* do not start up any interfaces */
            interfaces_requested = -1;
        } else if (!strcmp(argv[i], "-w")) {
            /* do not exit if there are no broadcast interfaces. */
            persist = 1;
        } else if (!strcmp(argv[i], "-e")) {
            struct string_list *tmp;
            if (++i == argc)
                usage();
            tmp = dmalloc(strlen(argv[i]) + sizeof *tmp, MDL);
            if (!tmp)
                log_fatal("No memory for %s", argv[i]);
            strcpy(tmp->string, argv[i]);
            tmp->next = client_env;
            client_env = tmp;
            client_env_count++;
#ifdef DHCPv6
        } else if (!strcmp(argv[i], "-S")) {
            if (local_family_set && (local_family == AF_INET)) {
                usage();
            }
            local_family_set = 1;
            local_family = AF_INET6;
            wanted_ia_na = 0;
            stateless = 1;
        } else if (!strcmp(argv[i], "-N")) {
            if (local_family_set && (local_family == AF_INET)) {
                usage();
            }
            local_family_set = 1;
            local_family = AF_INET6;
            if (wanted_ia_na < 0) {
                wanted_ia_na = 0;
            }
            wanted_ia_na++;
        } else if (!strcmp(argv[i], "-T")) {
            if (local_family_set && (local_family == AF_INET)) {
                usage();
            }
            local_family_set = 1;
            local_family = AF_INET6;
            if (wanted_ia_na < 0) {
                wanted_ia_na = 0;
            }
            wanted_ia_ta++;
        } else if (!strcmp(argv[i], "-P")) {
            if (local_family_set && (local_family == AF_INET)) {
                usage();
            }
            local_family_set = 1;
            local_family = AF_INET6;
            if (wanted_ia_na < 0) {
                wanted_ia_na = 0;
            }
            wanted_ia_pd++;
#endif /* DHCPv6 */
        } else if (!strcmp(argv[i], "-v")) {
            quiet = 0;
        } else if (!strcmp(argv[i], "--version")) {
            log_info("isc-dhclient-%s", PACKAGE_VERSION);
            exit(0);
        } else if (argv[i][0] == '-') {
            usage();
        } else if (interfaces_requested < 0) {
            usage();
        } else {
            struct interface_info *tmp = NULL;

            status = interface_allocate(&tmp, MDL);
            if (status != ISC_R_SUCCESS)
                log_fatal("Can't record interface %s:%s",
                    argv[i], isc_result_totext(status));
            if (strlen(argv[i]) >= sizeof(tmp->name))
                log_fatal("%s: interface name too long (is %ld)",
                    argv[i], (long)strlen(argv[i]));
            strcpy(tmp->name, argv[i]);
            if (interfaces) {
                interface_reference(&tmp->next,
                    interfaces, MDL);
                interface_dereference(&interfaces, MDL);
            }
            interface_reference(&interfaces, tmp, MDL);
            tmp->flags = INTERFACE_REQUESTED;
            interfaces_requested++;
        }
    }

    if (wanted_ia_na < 0) {
        wanted_ia_na = 1;
    }

    /* Support only one (requested) interface for Prefix Delegation. */
    if (wanted_ia_pd && (interfaces_requested != 1)) {
        usage();
    }

    if (!no_dhclient_conf && (s = getenv("PATH_DHCLIENT_CONF"))) {
        path_dhclient_conf = s;
    }
    if (!no_dhclient_db && (s = getenv("PATH_DHCLIENT_DB"))) {
        path_dhclient_db = s;
    }
    if (!no_dhclient_pid && (s = getenv("PATH_DHCLIENT_PID"))) {
        path_dhclient_pid = s;
    }
    if (!no_dhclient_script && (s = getenv("PATH_DHCLIENT_SCRIPT"))) {
        path_dhclient_script = s;
    }

    /* Set up the initial dhcp option universe. */
    initialize_common_option_spaces();

    /* Assign v4 or v6 specific running parameters. */
    if (local_family == AF_INET)
        dhcpv4_client_assignments();
#ifdef DHCPv6
    else if (local_family == AF_INET6)
        dhcpv6_client_assignments();
#endif /* DHCPv6 */
    else
        log_fatal("Impossible condition at %s:%d.", MDL);

    /*
     * convert relative path names to absolute, for files that need
     * to be reopened after chdir() has been called
     */
    if (path_dhclient_db[0] != '/') {
        char *path = dmalloc(PATH_MAX, MDL);
        if (path == NULL)
            log_fatal("No memory for filename\n");
        path_dhclient_db = realpath(path_dhclient_db, path);
        if (path_dhclient_db == NULL)
            log_fatal("%s: %s", path, strerror(errno));
    }

    if (path_dhclient_script[0] != '/') {
        char *path = dmalloc(PATH_MAX, MDL);
        if (path == NULL)
            log_fatal("No memory for filename\n");
        path_dhclient_script = realpath(path_dhclient_script, path);
        if (path_dhclient_script == NULL)
            log_fatal("%s: %s", path, strerror(errno));
    }

    /*
     * See if we should kill off any currently running client
     * we don't try to kill it off if the user told us not
     * to write a pid file - we assume they are controlling
     * the process in some other fashion.
     */
    if ((release_mode || exit_mode) && (no_pid_file == ISC_FALSE)) {
        FILE *pidfd;
        pid_t oldpid;
        long temp;
        int e;

        oldpid = 0;
        if ((pidfd = fopen(path_dhclient_pid, "r")) != NULL) {
            e = fscanf(pidfd, "%ld\n", &temp);
            oldpid = (pid_t)temp;

            if (e != 0 && e != EOF) {
                if (oldpid)
                    kill(oldpid, SIGTERM);
            }
            fclose(pidfd);
        }
    }

    if (!quiet) {
        log_info("%s %s", message, PACKAGE_VERSION);
        log_info(copyright);
        log_info(arr);
        log_info(url);
        log_info("%s", "");
    } else {
        log_perror = 0;
        quiet_interface_discovery = 1;
    }

    /* If we're given a relay agent address to insert, for testing
       purposes, figure out what it is. */
    if (mockup_relay) {
        if (!inet_aton(mockup_relay, &giaddr)) {
            struct hostent *he;
            he = gethostbyname(mockup_relay);
            if (he) {
                memcpy(&giaddr, he->h_addr_list[0],
                    sizeof giaddr);
            } else {
                log_fatal("%s: no such host", mockup_relay);
            }
        }
    }

    /* Get the current time... */
    //gettimeofday(&cur_tv, NULL);
    get_current_clocktime(&cur_tv, NULL); //TODO LiDong Mod.

    sockaddr_broadcast.sin_family = AF_INET;
    sockaddr_broadcast.sin_port = remote_port;
    if (server) {
        if (!inet_aton(server, &sockaddr_broadcast.sin_addr)) {
            struct hostent *he;
            he = gethostbyname(server);
            if (he) {
                memcpy(&sockaddr_broadcast.sin_addr,
                    he->h_addr_list[0],
                    sizeof sockaddr_broadcast.sin_addr);
            } else
                sockaddr_broadcast.sin_addr.s_addr =
                    INADDR_BROADCAST;
        }
    } else {
        sockaddr_broadcast.sin_addr.s_addr = INADDR_BROADCAST;
    }

    inaddr_any.s_addr = INADDR_ANY;

    /* Stateless special case. */
    if (stateless) {
        if (release_mode || (wanted_ia_na > 0) ||
            wanted_ia_ta || wanted_ia_pd ||
            (interfaces_requested != 1)) {
            usage();
        }
        run_stateless(exit_mode);
        return 0;
    }

    /* Discover all the network interfaces. */
    discover_interfaces(DISCOVER_UNCONFIGURED);

    /* Parse the dhclient.conf file. */
    read_client_conf();

    /* Parse the lease database. */
    read_client_leases();

    /* Rewrite the lease database... */
    rewrite_client_leases();

    /* XXX */
    /* 	config_counter(&snd_counter, &rcv_counter); */

    /*
     * If no broadcast interfaces were discovered, call the script
     * and tell it so.
     */
    if (!interfaces) {
        /*
         * Call dhclient-script with the NBI flag,
         * in case somebody cares.
         */
        script_init(NULL, "NBI", NULL);
        script_go(NULL);

        /*
         * If we haven't been asked to persist, waiting for new
         * interfaces, then just exit.
         */
        if (!persist) {
            /* Nothing more to do. */
            log_info("No broadcast interfaces found - exiting.");
            exit(0); //TODO never run here
        }
    } else if (!release_mode && !exit_mode) {
        /* Call the script with the list of interfaces. */
        for (ip = interfaces; ip; ip = ip->next) {
            /*
             * If interfaces were specified, don't configure
             * interfaces that weren't specified!
             */
            if ((interfaces_requested > 0) &&
                ((ip->flags & (INTERFACE_REQUESTED |
                               INTERFACE_AUTOMATIC)) !=
                 INTERFACE_REQUESTED))
                continue;

            if (local_family == AF_INET6) {
                script_init(ip->client, "PREINIT6", NULL);
            } else {
                script_init(ip->client, "PREINIT", NULL);
                if (ip->client->alias != NULL)
                    script_write_params(ip->client,
                        "alias_",
                        ip->client->alias);
            }
            script_go(ip->client);
        }
    }

    /* At this point, all the interfaces that the script thinks
       are relevant should be running, so now we once again call
       discover_interfaces(), and this time ask it to actually set
       up the interfaces. */
    discover_interfaces(interfaces_requested != 0
        ? DISCOVER_REQUESTED
        : DISCOVER_RUNNING);

    /* Make up a seed for the random number generator from current
       time plus the sum of the last four bytes of each
       interface's hardware address interpreted as an integer.
       Not much entropy, but we're booting, so we're not likely to
       find anything better. */
    seed = 0;
    for (ip = interfaces; ip; ip = ip->next) {
        int junk;
        memcpy(&junk,
            &ip->hw_address.hbuf[ip->hw_address.hlen -
            sizeof seed], sizeof seed);
        seed += junk;
    }
    srandom(seed + cur_time + (unsigned)getpid());

    /* Start a configuration state machine for each interface. */
#ifdef DHCPv6
    if (local_family == AF_INET6) {
        /* Establish a default DUID.  This may be moved to the
         * DHCPv4 area later.
         */
        if (default_duid.len == 0) {
            if (default_duid.buffer != NULL)
                data_string_forget(&default_duid, MDL);

            form_duid(&default_duid, MDL);
            write_duid(&default_duid);
        }

        for (ip = interfaces ; ip != NULL ; ip = ip->next) {
            for (client = ip->client ; client != NULL ;
                client = client->next) {
                if (release_mode) {
                    start_release6(client);
                    continue;
                } else if (exit_mode) {
                    unconfigure6(client, "STOP6");
                    continue;
                }

                /* If we have a previous binding, Confirm
                 * that we can (or can't) still use it.
                 */
                if ((client->active_lease != NULL) &&
                    !client->active_lease->released)
                    start_confirm6(client);
                else
                    start_init6(client); //TODO HDCPv6
            }
        }
    } else
#endif /* DHCPv6 */
    {
        for (ip = interfaces ; ip ; ip = ip->next) {
            ip->flags |= INTERFACE_RUNNING;
            for (client = ip->client ; client ;
                client = client->next) {
                if (exit_mode)
                    state_stop(client);
                else if (release_mode)
                    do_release(client);
                else {
                    client->state = S_INIT;

                    if (top_level_config.initial_delay>0)
                    {
                        tv.tv_sec = 0;
                        if (top_level_config.
                            initial_delay>1)
                            tv.tv_sec = cur_time
                                + random()
                                % (top_level_config.
                                    initial_delay-1);
                        tv.tv_usec = random()
                            % 1000000;
                        /*
                         * this gives better
                         * distribution than just
                         *whole seconds
                         */
                        add_timeout(&tv, state_reboot,
                            client, 0, 0);
                    } else {
                        state_reboot(client); //TODO DHCPv4
                    }
                }
            }
        }
    }

    if (exit_mode)
        return 0;
    if (release_mode) {
#ifndef DHCPv6
        return 0;
#else
        if (local_family == AF_INET6) {
            if (onetry)
                return 0;
        } else
            return 0;
#endif /* DHCPv6 */
    }

    /* Start up a listener for the object management API protocol. */
    if (top_level_config.omapi_port != -1) {
        listener = NULL;
        result = omapi_generic_new(&listener, MDL);
        if (result != ISC_R_SUCCESS)
            log_fatal("Can't allocate new generic object: %s\n",
                isc_result_totext(result));
        result = omapi_protocol_listen(listener,
            (unsigned)
            top_level_config.omapi_port,
            1);
        if (result != ISC_R_SUCCESS)
            log_fatal("Can't start OMAPI protocol: %s",
                isc_result_totext (result));
    }

    /* Set up the bootp packet handler... */
    bootp_packet_handler = do_packet;
#ifdef DHCPv6
    dhcpv6_packet_handler = do_packet6;
#endif /* DHCPv6 */

#if defined(DEBUG_MEMORY_LEAKAGE) || defined(DEBUG_MALLOC_POOL) || \
    defined(DEBUG_MEMORY_LEAKAGE_ON_EXIT)
    dmalloc_cutoff_generation = dmalloc_generation;
    dmalloc_longterm = dmalloc_outstanding;
    dmalloc_outstanding = 0;
#endif

    /* If we're not supposed to wait before getting the address,
       don't. */
    if (nowait)
        go_daemon();

    /* If we're not going to daemonize, write the pid file
       now. */
    if (no_daemon || nowait)
        write_client_pid_file();

    /* Start dispatching packets and timeouts... */
    dispatch();

    /*NOTREACHED*/
    return 0;
}

static void usage()
{
    log_info("%s %s", message, PACKAGE_VERSION);
    log_info(copyright);
    log_info(arr);
    log_info(url);


    log_fatal("Usage: dhclient "
#ifdef DHCPv6
        "[-4|-6] [-SNTP1dvrx] [-nw] [-p <port>]\n"
#else /* DHCPv6 */
        "[-1dvrx] [-nw] [-p <port>]\n"
#endif /* DHCPv6 */
        "                [-s server-addr] [-cf config-file] "
        "[-lf lease-file]\n"
        "                [-pf pid-file] [--no-pid] [-e VAR=val]\n"
        "                [-sf script-file] [interface]");
}

void run_stateless(int exit_mode)
{
#ifdef DHCPv6
    struct client_state *client;
    omapi_object_t *listener;
    isc_result_t result;

    /* Discover the network interface. */
    discover_interfaces(DISCOVER_REQUESTED);

    if (!interfaces)
        usage();

    /* Parse the dhclient.conf file. */
    read_client_conf();

    /* Parse the lease database. */
    read_client_leases();

    /* Establish a default DUID. */
    if (default_duid.len == 0) {
        if (default_duid.buffer != NULL)
            data_string_forget(&default_duid, MDL);

        form_duid(&default_duid, MDL);
    }

    /* Start a configuration state machine. */
    for (client = interfaces->client ;
        client != NULL ;
        client = client->next) {
        if (exit_mode) {
            unconfigure6(client, "STOP6");
            continue;
        }
        start_info_request6(client);
    }
    if (exit_mode)
        return;

    /* Start up a listener for the object management API protocol. */
    if (top_level_config.omapi_port != -1) {
        listener = NULL;
        result = omapi_generic_new(&listener, MDL);
        if (result != ISC_R_SUCCESS)
            log_fatal("Can't allocate new generic object: %s\n",
                isc_result_totext(result));
        result = omapi_protocol_listen(listener,
            (unsigned)
            top_level_config.omapi_port,
            1);
        if (result != ISC_R_SUCCESS)
            log_fatal("Can't start OMAPI protocol: %s",
                isc_result_totext(result));
    }

    /* Set up the packet handler... */
    dhcpv6_packet_handler = do_packet6;

#if defined(DEBUG_MEMORY_LEAKAGE) || defined(DEBUG_MALLOC_POOL) || \
    defined(DEBUG_MEMORY_LEAKAGE_ON_EXIT)
    dmalloc_cutoff_generation = dmalloc_generation;
    dmalloc_longterm = dmalloc_outstanding;
    dmalloc_outstanding = 0;
#endif

    /* If we're not supposed to wait before getting the address,
       don't. */
    if (nowait)
        go_daemon();

    /* If we're not going to daemonize, write the pid file
       now. */
    if (no_daemon || nowait)
        write_client_pid_file();

    /* Start dispatching packets and timeouts... */
    dispatch();

    /*NOTREACHED*/
#endif /* DHCPv6 */
    return;
}

isc_result_t find_class (struct class **c,
    const char *s, const char *file, int line)
{
    return 0;
}

int check_collection (packet, lease, collection)
    struct packet *packet;
    struct lease *lease;
    struct collection *collection;
{
    return 0;
}

void classify (packet, class)
    struct packet *packet;
    struct class *class;
{
}

int unbill_class (lease, class)
    struct lease *lease;
    struct class *class;
{
    return 0;
}

int find_subnet (struct subnet **sp,
    struct iaddr addr, const char *file, int line)
{
    return 0;
}

/* Individual States:
 *
 * Each routine is called from the dhclient_state_machine() in one of
 * these conditions:
 * -> entering INIT state
 * -> recvpacket_flag == 0: timeout in this state
 * -> otherwise: received a packet in this state
 *
 * Return conditions as handled by dhclient_state_machine():
 * Returns 1, sendpacket_flag = 1: send packet, reset timer.
 * Returns 1, sendpacket_flag = 0: just reset the timer (wait for a milestone).
 * Returns 0: finish the nap which was interrupted for no good reason.
 *
 * Several per-interface variables are used to keep track of the process:
 *   active_lease: the lease that is being used on the interface
 *                 (null pointer if not configured yet).
 *   offered_leases: leases corresponding to DHCPOFFER messages that have
 *		     been sent to us by DHCP servers.
 *   acked_leases: leases corresponding to DHCPACK messages that have been
 *		   sent to us by DHCP servers.
 *   sendpacket: DHCP packet we're trying to send.
 *   destination: IP address to send sendpacket to
 * In addition, there are several relevant per-lease variables.
 *   T1_expiry, T2_expiry, lease_expiry: lease milestones
 * In the active lease, these control the process of renewing the lease;
 * In leases on the acked_leases list, this simply determines when we
 * can no longer legitimately use the lease.
 */

void state_reboot (cpp)
    void *cpp;
{
    struct client_state *client = cpp;

    /* If we don't remember an active lease, go straight to INIT. */
    if (!client -> active ||
        client -> active -> is_bootp ||
        client -> active -> expiry <= cur_time) {
        state_init (client);
        return;
    }

    /* We are in the rebooting state. */
    client -> state = S_REBOOTING;

    /*
     * make_request doesn't initialize xid because it normally comes
     * from the DHCPDISCOVER, but we haven't sent a DHCPDISCOVER,
     * so pick an xid now.
     */
    client -> xid = random ();

    /*
     * Make a DHCPREQUEST packet, and set
     * appropriate per-interface flags.
     */
    make_request (client, client -> active);
    client -> destination = iaddr_broadcast;
    client -> first_sending = cur_time;
    client -> interval = client -> config -> initial_interval;

    /* Zap the medium list... */
    client -> medium = NULL;

    /* Send out the first DHCPREQUEST packet. */
    send_request (client);
}

/* Called when a lease has completely expired and we've been unable to
   renew it. */

void state_init (cpp)
    void *cpp;
{
    int i = 0;
    struct client_state *client = cpp;

    ASSERT_STATE(state, S_INIT);

    /* Make a DHCPDISCOVER packet, and set appropriate per-interface
       flags. */
    make_discover (client, client -> active);
    client -> xid = client -> packet.xid;
    client -> destination = iaddr_broadcast;
    client -> state = S_SELECTING;
    client -> first_sending = cur_time;
    client -> interval = client -> config -> initial_interval;

    //TODO lidong add. adjust timeout
    client -> hw_cur_idx = 0;
    client -> hw_cur_try = 0;
    if (client->config->hw_retrans_seq[0] > 0) {
        client->config->timeout = 0;
        while (i++ < client->config->hw_retrans_seq[0]) {
            client->config->timeout += client->config->hw_retrans_seq[i];
        }
        if (client->config->hw_retry_interval > 0) 
            client->config->timeout += client->config->hw_retry_interval; 
        DHCP_LOG_INFO("timeout = %d\n", client->config->timeout);
    }
        

    /* Add an immediate timeout to cause the first DHCPDISCOVER packet
       to go out. */
    send_discover (client);
}

/*
 * state_selecting is called when one or more DHCPOFFER packets have been
 * received and a configurable period of time has passed.
 */

void state_selecting (cpp)
    void *cpp;
{
    struct client_state *client = cpp;
    struct client_lease *lp, *next, *picked;


    ASSERT_STATE(state, S_SELECTING);

    /*
     * Cancel state_selecting and send_discover timeouts, since either
     * one could have got us here.
     */
    cancel_timeout (state_selecting, client);
    cancel_timeout (send_discover, client);

    /*
     * We have received one or more DHCPOFFER packets.   Currently,
     * the only criterion by which we judge leases is whether or
     * not we get a response when we arp for them.
     */
    picked = NULL;
    for (lp = client -> offered_leases; lp; lp = next) {
        next = lp -> next;

        /*
         * Check to see if we got an ARPREPLY for the address
         * in this particular lease.
         */
        if (!picked) {
            picked = lp;
            picked -> next = NULL;
        } else {
            destroy_client_lease (lp);
        }
    }
    client -> offered_leases = NULL;

    /*
     * If we just tossed all the leases we were offered, go back
     * to square one.
     */
    if (!picked) {
        client -> state = S_INIT;
        state_init (client);
        return;
    }

    /* If it was a BOOTREPLY, we can just take the address right now. */
    if (picked -> is_bootp) {
        client -> new = picked;

        /* Make up some lease expiry times
           XXX these should be configurable. */
        client -> new -> expiry = cur_time + 12000;
        client -> new -> renewal += cur_time + 8000;
        client -> new -> rebind += cur_time + 10000;

        client -> state = S_REQUESTING;

        //TODO lidong add. never run here in generally.
        DHCP_LOG_WARN("di di da che.\n");
        client->hw_cur_idx = 0; 
        client->config->hw_leasetime_seq[0] = 0;
        /* Bind to the address we received. */
        bind_lease (client);
        return;
    }

    /* Go to the REQUESTING state. */
    client -> destination = iaddr_broadcast;
    client -> state = S_REQUESTING;
    client -> first_sending = cur_time;
    client -> interval = client -> config -> initial_interval;

    /* Make a DHCPREQUEST packet from the lease we picked. */
    make_request (client, picked);
    client -> xid = client -> packet.xid;

    /* Toss the lease we picked - we'll get it back in a DHCPACK. */
    destroy_client_lease (picked);

    /* Add an immediate timeout to send the first DHCPREQUEST packet. */
    send_request (client);
}

/* state_requesting is called when we receive a DHCPACK message after
   having sent out one or more DHCPREQUEST packets. */

void dhcpack (packet)
    struct packet *packet;
{
    struct interface_info *ip = packet -> interface;
    struct client_state *client;
    struct client_lease *lease;
    struct option_cache *oc;
    struct data_string ds;

    /* If we're not receptive to an offer right now, or if the offer
       has an unrecognizable transaction id, then just drop it. */
    for (client = ip -> client; client; client = client -> next) {
        if (client -> xid == packet -> raw -> xid)
            break;
    }
    if (!client ||
        (packet -> interface -> hw_address.hlen - 1 !=
         packet -> raw -> hlen) ||
        (memcmp (&packet -> interface -> hw_address.hbuf [1],
                 packet -> raw -> chaddr, packet -> raw -> hlen))) {
#if defined (DEBUG)
        log_debug ("DHCPACK in wrong transaction.");
#endif
        return;
    }

    if (client -> state != S_REBOOTING &&
        client -> state != S_REQUESTING &&
        client -> state != S_RENEWING &&
        client -> state != S_REBINDING) {
#if defined (DEBUG)
        log_debug ("DHCPACK in wrong state.");
#endif
        return;
    }

    log_info ("DHCPACK from %s", piaddr (packet -> client_addr));

    lease = packet_to_lease (packet, client);
    if (!lease) {
        log_info ("packet_to_lease failed.");
        return;
    }

    client -> new = lease;

    /* Stop resending DHCPREQUEST. */
    cancel_timeout (send_request, client);

    /* Figure out the lease time. */
    oc = lookup_option (&dhcp_universe, client -> new -> options,
        DHO_DHCP_LEASE_TIME);
    memset (&ds, 0, sizeof ds);
    if (oc &&
        evaluate_option_cache (&ds, packet, (struct lease *)0, client,
            packet -> options, client -> new -> options,
            &global_scope, oc, MDL)) {
        if (ds.len > 3)
            client -> new -> expiry = getULong (ds.data);
        else
            client -> new -> expiry = 0;
        data_string_forget (&ds, MDL);
    } else
        client -> new -> expiry = 0;

    if (client->new->expiry == 0) {
        struct timeval tv;

        log_error ("no expiry time on offered lease.");

        /* Quench this (broken) server.  Return to INIT to reselect. */
        add_reject(packet);

        /* 1/2 second delay to restart at INIT. */
        tv.tv_sec = cur_tv.tv_sec;
        tv.tv_usec = cur_tv.tv_usec + 500000;

        if (tv.tv_usec >= 1000000) {
            tv.tv_sec++;
            tv.tv_usec -= 1000000;
        }

        add_timeout(&tv, state_init, client, 0, 0);
        return;
    }

    /*
     * A number that looks negative here is really just very large,
     * because the lease expiry offset is unsigned.
     */
    if (client->new->expiry < 0)
        client->new->expiry = TIME_MAX;

    /* Take the server-provided renewal time if there is one. */
    oc = lookup_option (&dhcp_universe, client -> new -> options,
        DHO_DHCP_RENEWAL_TIME);
    if (oc &&
        evaluate_option_cache (&ds, packet, (struct lease *)0, client,
            packet -> options, client -> new -> options,
            &global_scope, oc, MDL)) {
        if (ds.len > 3)
            client -> new -> renewal = getULong (ds.data);
        else
            client -> new -> renewal = 0;
        data_string_forget (&ds, MDL);
    } else
        client -> new -> renewal = 0;

    /* If it wasn't specified by the server, calculate it. */
    if (!client -> new -> renewal)
        client -> new -> renewal = client -> new -> expiry / 2 + 1;

    if (client -> new -> renewal <= 0)
        client -> new -> renewal = TIME_MAX;

    /* Now introduce some randomness to the renewal time: */
    if (client->new->renewal <= ((TIME_MAX / 3) - 3))
        client->new->renewal = (((client->new->renewal * 3) + 3) / 4) +
            (((random() % client->new->renewal) + 3) / 4);

    /* Same deal with the rebind time. */
    oc = lookup_option (&dhcp_universe, client -> new -> options,
        DHO_DHCP_REBINDING_TIME);
    if (oc &&
        evaluate_option_cache (&ds, packet, (struct lease *)0, client,
            packet -> options, client -> new -> options,
            &global_scope, oc, MDL)) {
        if (ds.len > 3)
            client -> new -> rebind = getULong (ds.data);
        else
            client -> new -> rebind = 0;
        data_string_forget (&ds, MDL);
    } else
        client -> new -> rebind = 0;

    if (client -> new -> rebind <= 0) {
        if (client -> new -> expiry <= TIME_MAX / 7)
            client -> new -> rebind =
                client -> new -> expiry * 7 / 8;
        else
            client -> new -> rebind =
                client -> new -> expiry / 8 * 7;
    }

    /* Make sure our randomness didn't run the renewal time past the
       rebind time. */
    if (client -> new -> renewal > client -> new -> rebind) {
        if (client -> new -> rebind <= TIME_MAX / 3)
            client -> new -> renewal =
                client -> new -> rebind * 3 / 4;
        else
            client -> new -> renewal =
                client -> new -> rebind / 4 * 3;
    }

    //TODO lidong add.
    client->hw_cur_idx = 0;
    float* leaseseq = &client->config->hw_leasetime_seq[0];
    if (*leaseseq > 0) {
        int t = (int)(*leaseseq / 2) + 1;
        client->hw_expiry = client -> new -> expiry;
        client->new->renewal = client->hw_expiry * leaseseq[1];
        client->new->rebind = client->hw_expiry * leaseseq[t];
        client->hw_cur_idx++;
    }

    client -> new -> expiry += cur_time;
    /* Lease lengths can never be negative. */
    if (client -> new -> expiry < cur_time)
        client -> new -> expiry = TIME_MAX;
    client -> new -> renewal += cur_time;
    if (client -> new -> renewal < cur_time)
        client -> new -> renewal = TIME_MAX;
    client -> new -> rebind += cur_time;
    if (client -> new -> rebind < cur_time)
        client -> new -> rebind = TIME_MAX;

    DHCP_LOG_INFO("T1[%ld] T2[%ld] Expiry[%ld]\n", client -> new -> renewal, client -> new -> rebind, 	client -> new -> expiry);
    bind_lease (client);
}

void bind_lease (client)
    struct client_state *client;
{
    struct timeval tv;

    /* Remember the medium. */
    client -> new -> medium = client -> medium;

    /* Run the client script with the new parameters. */
    if (client -> state != S_RENEWING)
        client -> hw_errcode = DHCP_ERRORCODE_BASE; //TODO LiDong add.
    script_init (client, (client -> state == S_REQUESTING
            ? "BOUND"
            : (client -> state == S_RENEWING
                ? "RENEW"
                : (client -> state == S_REBOOTING
                    ? "REBOOT" : "REBIND"))),
        client -> new -> medium);
    if (client -> active && client -> state != S_REBOOTING)
        script_write_params (client, "old_", client -> active);
    script_write_params (client, "new_", client -> new);
    if (client -> alias)
        script_write_params (client, "alias_", client -> alias);

    /* If the BOUND/RENEW code detects another machine using the
       offered address, it exits nonzero.  We need to send a
       DHCPDECLINE and toss the lease. */
    if (script_go (client)) {
        make_decline (client, client -> new);
        send_decline (client);
        destroy_client_lease (client -> new);
        client -> new = (struct client_lease *)0;
        state_init (client);
        return;
    }

    /* Write out the new lease if it has been long enough. */
    if (!client->last_write ||
        (cur_time - client->last_write) >= MIN_LEASE_WRITE)
        write_client_lease(client, client->new, 0, 0);

    /* Replace the old active lease with the new one. */
    if (client -> active)
        destroy_client_lease (client -> active);
    client -> active = client -> new;
    client -> new = (struct client_lease *)0;

    /* Set up a timeout to start the renewal process. */
    tv.tv_sec = client->active->renewal;
    tv.tv_usec = ((client->active->renewal - cur_tv.tv_sec) > 1) ?
        random() % 1000000 : cur_tv.tv_usec;
    add_timeout(&tv, state_bound, client, 0, 0);

    log_info ("bound to %s -- renewal in %ld seconds.",
        piaddr (client -> active -> address),
        (long)(client -> active -> renewal - cur_time));
    client -> state = S_BOUND;
    reinitialize_interfaces ();
    go_daemon ();
    if (client->config->do_forward_update)
        dhclient_schedule_updates(client, &client->active->address, 1);
}

/* state_bound is called when we've successfully bound to a particular
   lease, but the renewal time on that lease has expired.   We are
   expected to unicast a DHCPREQUEST to the server that gave us our
   original lease. */

void state_bound (cpp)
    void *cpp;
{
    struct client_state *client = cpp;
    struct option_cache *oc;
    struct data_string ds;

    ASSERT_STATE(state, S_BOUND);

    /* T1 has expired. */
    make_request (client, client -> active);
    client -> xid = client -> packet.xid;

    memset (&ds, 0, sizeof ds);
    oc = lookup_option (&dhcp_universe, client -> active -> options,
        DHO_DHCP_SERVER_IDENTIFIER);
    if (oc &&
        evaluate_option_cache (&ds, (struct packet *)0, (struct lease *)0,
            client, (struct option_state *)0,
            client -> active -> options,
            &global_scope, oc, MDL)) {
        if (ds.len > 3) {
            memcpy (client -> destination.iabuf, ds.data, 4);
            client -> destination.len = 4;
        } else
            client -> destination = iaddr_broadcast;

        data_string_forget (&ds, MDL);
    } else
        client -> destination = iaddr_broadcast;

    client -> first_sending = cur_time;
    client -> interval = client -> config -> initial_interval;
    client -> state = S_RENEWING;

    /* Send the first packet immediately. */
    send_request (client);
}

/* state_stop is called when we've been told to shut down.   We unconfigure
   the interfaces, and then stop operating until told otherwise. */

void state_stop (cpp)
    void *cpp;
{
    struct client_state *client = cpp;

    /* Cancel all timeouts. */
    cancel_timeout(state_selecting, client);
    cancel_timeout(send_discover, client);
    cancel_timeout(send_request, client);
    cancel_timeout(state_bound, client);

    /* If we have an address, unconfigure it. */
    if (client->active) {
        script_init(client, "STOP", client->active->medium);
        script_write_params(client, "old_", client->active);
        if (client->alias)
            script_write_params(client, "alias_", client->alias);
        script_go(client);
    }
}

int commit_leases ()
{
    return 0;
}

int write_lease (lease)
    struct lease *lease;
{
    return 0;
}

int write_host (host)
    struct host_decl *host;
{
    return 0;
}

void db_startup (testp)
    int testp;
{
}

void bootp (packet)
    struct packet *packet;
{
    struct iaddrmatchlist *ap;
    char addrbuf[4*16];
    char maskbuf[4*16];

    if (packet -> raw -> op != BOOTREPLY)
        return;

    /* If there's a reject list, make sure this packet's sender isn't
       on it. */
    for (ap = packet -> interface -> client -> config -> reject_list;
        ap; ap = ap -> next) {
        if (addr_match(&packet->client_addr, &ap->match)) {

            /* piaddr() returns its result in a static
               buffer sized 4*16 (see common/inet.c). */

            strcpy(addrbuf, piaddr(ap->match.addr));
            strcpy(maskbuf, piaddr(ap->match.mask));

            log_info("BOOTREPLY from %s rejected by rule %s "
                "mask %s.", piaddr(packet->client_addr),
                addrbuf, maskbuf);
            return;
        }
    }

    dhcpoffer (packet);

}

void dhcp (packet)
    struct packet *packet;
{
    struct iaddrmatchlist *ap;
    void (*handler) (struct packet *);
    const char *type;
    char addrbuf[4*16];
    char maskbuf[4*16];

    switch (packet -> packet_type) {
    case DHCPOFFER:
        handler = dhcpoffer;
        type = "DHCPOFFER";
        break;

    case DHCPNAK:
        handler = dhcpnak;
        type = "DHCPNACK";
        break;

    case DHCPACK:
        handler = dhcpack;
        type = "DHCPACK";
        break;

    default:
        return;
    }

    /* If there's a reject list, make sure this packet's sender isn't
       on it. */
    for (ap = packet -> interface -> client -> config -> reject_list;
        ap; ap = ap -> next) {
        if (addr_match(&packet->client_addr, &ap->match)) {

            /* piaddr() returns its result in a static
               buffer sized 4*16 (see common/inet.c). */

            strcpy(addrbuf, piaddr(ap->match.addr));
            strcpy(maskbuf, piaddr(ap->match.mask));

            log_info("%s from %s rejected by rule %s mask %s.",
                type, piaddr(packet->client_addr),
                addrbuf, maskbuf);
            return;
        }
    }
    (*handler) (packet);
}

#ifdef DHCPv6
void
dhcpv6(struct packet *packet) {
    struct iaddrmatchlist *ap;
    struct client_state *client;
    char addrbuf[sizeof("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")];

    /* Silently drop bogus messages. */
    if (packet->dhcpv6_msg_type >= dhcpv6_type_name_max)
        return;

    /* Discard, with log, packets from quenched sources. */
    for (ap = packet->interface->client->config->reject_list ;
        ap ; ap = ap->next) {
        if (addr_match(&packet->client_addr, &ap->match)) {
            strcpy(addrbuf, piaddr(packet->client_addr));
            log_info("%s from %s rejected by rule %s",
                dhcpv6_type_names[packet->dhcpv6_msg_type],
                addrbuf,
                piaddrmask(&ap->match.addr, &ap->match.mask));
            return;
        }
    }

    /* Screen out nonsensical messages. */
    switch(packet->dhcpv6_msg_type) {
    case DHCPV6_ADVERTISE:
    case DHCPV6_RECONFIGURE:
        if (stateless)
            return;
        /* Falls through */
    case DHCPV6_REPLY:
        log_info("RCV: %s message on %s from %s.",
            dhcpv6_type_names[packet->dhcpv6_msg_type],
            packet->interface->name, piaddr(packet->client_addr));
        break;

    default:
        return;
    }

    /* Find a client state that matches the incoming XID. */
    for (client = packet->interface->client ; client ;
        client = client->next) {
        if (memcmp(&client->dhcpv6_transaction_id,
                packet->dhcpv6_transaction_id, 3) == 0) {
            client->v6_handler(packet, client);
            return;
        }
    }

    /* XXX: temporary log for debugging */
    log_info("Packet received, but nothing done with it.");
}
#endif /* DHCPv6 */

void dhcpoffer (packet)
    struct packet *packet;
{
    struct interface_info *ip = packet -> interface;
    struct client_state *client;
    struct client_lease *lease, *lp;
    struct option **req;
    int i;
    int stop_selecting;
    const char *name = packet -> packet_type ? "DHCPOFFER" : "BOOTREPLY";
    char obuf [1024];
    struct timeval tv;

#ifdef DEBUG_PACKET
    dump_packet (packet);
#endif

    /* Find a client state that matches the xid... */
    for (client = ip -> client; client; client = client -> next)
        if (client -> xid == packet -> raw -> xid)
            break;

    /* If we're not receptive to an offer right now, or if the offer
       has an unrecognizable transaction id, then just drop it. */
    if (!client ||
        client -> state != S_SELECTING ||
        (packet -> interface -> hw_address.hlen - 1 !=
         packet -> raw -> hlen) ||
        (memcmp (&packet -> interface -> hw_address.hbuf [1],
                 packet -> raw -> chaddr, packet -> raw -> hlen))) {
#if defined (DEBUG)
        log_debug ("%s in wrong transaction.", name);
#endif
        return;
    }

    sprintf (obuf, "%s from %s", name, piaddr (packet -> client_addr));


    /* If this lease doesn't supply the minimum required DHCPv4 parameters,
     * ignore it.
     */
    req = client->config->required_options;
    if (req != NULL) {
        for (i = 0 ; req[i] != NULL ; i++) {
            if ((req[i]->universe == &dhcp_universe) &&
                !lookup_option(&dhcp_universe, packet->options,
                    req[i]->code)) {
                struct option *option = NULL;
                unsigned code = req[i]->code;

                option_code_hash_lookup(&option,
                    dhcp_universe.code_hash,
                    &code, 0, MDL);

                if (option)
                    log_info("%s: no %s option.", obuf,
                        option->name);
                else
                    log_info("%s: no unknown-%u option.",
                        obuf, code);

                option_dereference(&option, MDL);

                return;
            }
        }
    }

    /* If we've already seen this lease, don't record it again. */
    for (lease = client -> offered_leases; lease; lease = lease -> next) {
        if (lease -> address.len == sizeof packet -> raw -> yiaddr &&
            !memcmp (lease -> address.iabuf,
                &packet -> raw -> yiaddr, lease -> address.len)) {
            log_debug ("%s: already seen.", obuf);
            return;
        }
    }

    lease = packet_to_lease (packet, client);
    if (!lease) {
        log_info ("%s: packet_to_lease failed.", obuf);
        return;
    }

    /* If this lease was acquired through a BOOTREPLY, record that
       fact. */
    if (!packet -> options_valid || !packet -> packet_type)
        lease -> is_bootp = 1;

    /* Record the medium under which this lease was offered. */
    lease -> medium = client -> medium;

    /* Figure out when we're supposed to stop selecting. */
    stop_selecting = (client -> first_sending +
        client -> config -> select_interval);

    /* If this is the lease we asked for, put it at the head of the
       list, and don't mess with the arp request timeout. */
    if (lease -> address.len == client -> requested_address.len &&
        !memcmp (lease -> address.iabuf,
            client -> requested_address.iabuf,
            client -> requested_address.len)) {
        lease -> next = client -> offered_leases;
        client -> offered_leases = lease;
    } else {
        /* Put the lease at the end of the list. */
        lease -> next = (struct client_lease *)0;
        if (!client -> offered_leases)
            client -> offered_leases = lease;
        else {
            for (lp = client -> offered_leases; lp -> next;
                lp = lp -> next)
                ;
            lp -> next = lease;
        }
    }

    /* If the selecting interval has expired, go immediately to
       state_selecting().  Otherwise, time out into
       state_selecting at the select interval. */
    if (stop_selecting <= cur_tv.tv_sec)
        state_selecting (client);
    else {
        tv.tv_sec = stop_selecting;
        tv.tv_usec = cur_tv.tv_usec;
        add_timeout(&tv, state_selecting, client, 0, 0);
        cancel_timeout(send_discover, client);
    }
    log_info("%s", obuf);
}

/* Allocate a client_lease structure and initialize it from the parameters
   in the specified packet. */

struct client_lease *packet_to_lease (packet, client)
    struct packet *packet;
    struct client_state *client;
{
    struct client_lease *lease;
    unsigned i;
    struct option_cache *oc;
    struct option *option = NULL;
    struct data_string data;

    lease = (struct client_lease *)new_client_lease (MDL);

    if (!lease) {
        log_error ("packet_to_lease: no memory to record lease.\n");
        return (struct client_lease *)0;
    }

    memset (lease, 0, sizeof *lease);

    /* Copy the lease options. */
    option_state_reference (&lease -> options, packet -> options, MDL);

    lease -> address.len = sizeof (packet -> raw -> yiaddr);
    memcpy (lease -> address.iabuf, &packet -> raw -> yiaddr,
        lease -> address.len);

    memset (&data, 0, sizeof data);

    if (client -> config -> vendor_space_name) {
        i = DHO_VENDOR_ENCAPSULATED_OPTIONS;

        /* See if there was a vendor encapsulation option. */
        oc = lookup_option (&dhcp_universe, lease -> options, i);
        if (oc &&
            client -> config -> vendor_space_name &&
            evaluate_option_cache (&data, packet,
                (struct lease *)0, client,
                packet -> options, lease -> options,
                &global_scope, oc, MDL)) {
            if (data.len) {
                if (!option_code_hash_lookup(&option,
                        dhcp_universe.code_hash,
                        &i, 0, MDL))
                    log_fatal("Unable to find VENDOR "
                        "option (%s:%d).", MDL);
                parse_encapsulated_suboptions
                    (packet -> options, option,
                     data.data, data.len, &dhcp_universe,
                     client -> config -> vendor_space_name
                    );

                option_dereference(&option, MDL);
            }
            data_string_forget (&data, MDL);
        }
    } else
        i = 0;

    //TODO lidong add. option125, need think.
    if (client -> config -> hw_verify) {
        unsigned char* pdata = 0, *pEnd = 0;
        unsigned int enterprise_number = 0; 
        unsigned int enterprise_length = 0;
        unsigned int subopt_code = 0;
        unsigned int subopt_size = 0;
        oc = lookup_option (&dhcp_universe, lease->options, DHO_VIVSO_SUBOPTIONS);
        if (oc &&
            client -> config -> hw_verify &&
            evaluate_option_cache (&data, packet,
                (struct lease *)0, client,
                packet -> options, lease -> options,
                &global_scope, oc, MDL)) {
            int match = 0;
            while (!match && (i + 5) < data.len) {
                pdata = (unsigned char*)&data.data[i];
                enterprise_number = (unsigned int)(pdata[0] << 24 | pdata[1] << 16 | pdata[2] << 8 | pdata[3]);
                enterprise_length = (unsigned int)(pdata[4]);
                pdata += 5;
                if (enterprise_number == client-> config->hw_enterprise) {
                    if (client->config->hw_subopt125 < 0) {
                        //no sub options
                        if (!memcmp(pdata, client->config->hw_verify, enterprise_length))
                            match = 1;
                    } else {
                        //parse sub options
                        pEnd = pdata + enterprise_length;
                        while (!match && (pdata + 2) < pEnd) { 
                            subopt_code = (unsigned int)(pdata[0]);
                            subopt_size = (unsigned int)(pdata[1]);
                            if (subopt_code == client->config->hw_subopt125) {
                                if (!memcmp(&pdata[2], client->config->hw_verify, subopt_size))
                                    match = 1;
                            }
                            pdata += (2 + subopt_size);
                        }
                    }
                } 
                i += (5 + enterprise_length);
            }
            data_string_forget (&data, MDL);
            if (!match) {
                DHCP_LOG_WARN("not match:%s\n", client-> config->hw_verify);
                return 0;
            }
        } else {
            DHCP_LOG_WARN("not found enterprise:%d\n", client->config->hw_enterprise);
            return 0;
        }
    }

    /* Figure out the overload flag. */
    oc = lookup_option (&dhcp_universe, lease -> options,
        DHO_DHCP_OPTION_OVERLOAD);
    if (oc &&
        evaluate_option_cache (&data, packet, (struct lease *)0, client,
            packet -> options, lease -> options,
            &global_scope, oc, MDL)) {
        if (data.len > 0)
            i = data.data [0];
        else
            i = 0;
        data_string_forget (&data, MDL);
    } else
        i = 0;

    /* If the server name was filled out, copy it. */
    if (!(i & 2) && packet -> raw -> sname [0]) {
        unsigned len;
        /* Don't count on the NUL terminator. */
        for (len = 0; len < DHCP_SNAME_LEN; len++)
            if (!packet -> raw -> sname [len])
                break;
        lease -> server_name = dmalloc (len + 1, MDL);
        if (!lease -> server_name) {
            log_error ("dhcpoffer: no memory for server name.\n");
            destroy_client_lease (lease);
            return (struct client_lease *)0;
        } else {
            memcpy (lease -> server_name,
                packet -> raw -> sname, len);
            lease -> server_name [len] = 0;
        }
    }

    /* Ditto for the filename. */
    if (!(i & 1) && packet -> raw -> file [0]) {
        unsigned len;
        /* Don't count on the NUL terminator. */
        for (len = 0; len < DHCP_FILE_LEN; len++)
            if (!packet -> raw -> file [len])
                break;
        lease -> filename = dmalloc (len + 1, MDL);
        if (!lease -> filename) {
            log_error ("dhcpoffer: no memory for filename.\n");
            destroy_client_lease (lease);
            return (struct client_lease *)0;
        } else {
            memcpy (lease -> filename,
                packet -> raw -> file, len);
            lease -> filename [len] = 0;
        }
    }

    execute_statements_in_scope ((struct binding_value **)0,
        (struct packet *)packet,
        (struct lease *)0, client,
        lease -> options, lease -> options,
        &global_scope,
        client -> config -> on_receipt,
        (struct group *)0);

    return lease;
}

void dhcpnak (packet)
    struct packet *packet;
{
    struct interface_info *ip = packet -> interface;
    struct client_state *client;

    /* Find a client state that matches the xid... */
    for (client = ip -> client; client; client = client -> next)
        if (client -> xid == packet -> raw -> xid)
            break;

    /* If we're not receptive to an offer right now, or if the offer
       has an unrecognizable transaction id, then just drop it. */
    if (!client ||
        (packet -> interface -> hw_address.hlen - 1 !=
         packet -> raw -> hlen) ||
        (memcmp (&packet -> interface -> hw_address.hbuf [1],
                 packet -> raw -> chaddr, packet -> raw -> hlen))) {
#if defined (DEBUG)
        log_debug ("DHCPNAK in wrong transaction.");
#endif
        return;
    }

    if (client -> state != S_REBOOTING &&
        client -> state != S_REQUESTING &&
        client -> state != S_RENEWING &&
        client -> state != S_REBINDING) {
#if defined (DEBUG)
        log_debug ("DHCPNAK in wrong state.");
#endif
        return;
    }

    log_info ("DHCPNAK from %s", piaddr (packet -> client_addr));

    if (!client -> active) {
#if defined (DEBUG)
        log_info ("DHCPNAK with no active lease.\n");
#endif
        return;
    }

    /* If we get a DHCPNAK, we use the EXPIRE dhclient-script state
     * to indicate that we want all old bindings to be removed.  (It
     * is possible that we may get a NAK while in the RENEW state,
     * so we might have bindings active at that time)
     */
    client->hw_errcode = DHCP_REQUEST_TIMEDOUT; //TODO LiDong add.
    script_init(client, "EXPIRE", NULL);
    script_write_params(client, "old_", client->active);
    if (client->alias)
        script_write_params(client, "alias_", client->alias);
    script_go(client);

    destroy_client_lease (client -> active);
    client -> active = (struct client_lease *)0;

    /* Stop sending DHCPREQUEST packets... */
    cancel_timeout (send_request, client);

    /* On some scripts, 'EXPIRE' causes the interface to be ifconfig'd
     * down (this expunges any routes and arp cache).  This makes the
     * interface unusable by state_init(), which we call next.  So, we
     * need to 'PREINIT' the interface to bring it back up.
     */
    script_init(client, "PREINIT", NULL);
    if (client->alias)
        script_write_params(client, "alias_", client->alias);
    script_go(client);

    client -> state = S_INIT;
    state_init (client);
}

/* Send out a DHCPDISCOVER packet, and set a timeout to send out another
   one after the right interval has expired.  If we don't get an offer by
   the time we reach the panic interval, call the panic function. */

void send_discover (cpp)
    void *cpp;
{
    struct client_state *client = cpp;

    int result;
    int interval;
    int increase = 1;
    struct timeval tv;

    /* Figure out how long it's been since we started transmitting. */
    interval = cur_time - client -> first_sending;

    /* If we're past the panic timeout, call the script and tell it
       we haven't found anything for this interface yet. */
    if (interval >= client -> config -> timeout) {
        state_panic (client);
        return;
    }

    /* If we're selecting media, try the whole list before doing
       the exponential backoff, but if we've already received an
       offer, stop looping, because we obviously have it right. */
    if (!client -> offered_leases &&
        client -> config -> media) {
        int fail = 0;
again:
        if (client -> medium) {
            client -> medium = client -> medium -> next;
            increase = 0;
        }
        if (!client -> medium) {
            if (fail)
                log_fatal ("No valid media types for %s!",
                    client -> interface -> name);
            client -> medium =
                client -> config -> media;
            increase = 1;
        }

        log_info ("Trying medium \"%s\" %d",
            client -> medium -> string, increase);
        script_init (client, "MEDIUM", client -> medium);
        if (script_go (client)) {
            fail = 1;
            goto again;
        }
    }

    /* If we're supposed to increase the interval, do so.  If it's
       currently zero (i.e., we haven't sent any packets yet), set
       it to initial_interval; otherwise, add to it a random number
       between zero and two times itself.  On average, this means
       that it will double with every transmission. */
    if (increase) {
        if (!client->interval)
            client->interval = client->config->initial_interval;
        else
            client->interval += random() % (2 * client->interval);

        /* Don't backoff past cutoff. */
        if (client->interval > client->config->backoff_cutoff)
            client->interval = (client->config->backoff_cutoff / 2)
                + (random() % client->config->backoff_cutoff);
    } else if (!client->interval)
        client->interval = client->config->initial_interval;

    //TODO lidong add.
    int* retrans = &client->config->hw_retrans_seq[0];
    if (*retrans > 0) {
        if (client->hw_cur_idx < *retrans)
            client->interval = *(retrans + 1 + client->hw_cur_idx++);
        else
            client->interval = client->config->hw_retry_interval;
        DHCP_LOG_INFO("curidx[%d] / req[%d]  interval[%d]\n", client->hw_cur_idx, *retrans,  client->interval);
    } else { 
        /* If the backoff would take us to the panic timeout, just use that
           as the interval. */
        if (cur_time + client -> interval >
            client -> first_sending + client -> config -> timeout)
            client -> interval =
                (client -> first_sending +
                 client -> config -> timeout) - cur_time + 1;
    }

    /* Record the number of seconds since we started sending. */
    if (interval < 65536)
        client -> packet.secs = htons (interval);
    else
        client -> packet.secs = htons (65535);
    client -> secs = client -> packet.secs;

    log_info ("DHCPDISCOVER on %s to %s port %d interval %ld",
        client -> name ? client -> name : client -> interface -> name,
        inet_ntoa (sockaddr_broadcast.sin_addr),
        ntohs (sockaddr_broadcast.sin_port), (long)(client -> interval));

    /* Send out a packet. */
    result = send_packet (client -> interface, (struct packet *)0,
        &client -> packet,
        client -> packet_length,
        inaddr_any, &sockaddr_broadcast,
        (struct hardware *)0);
     if (result < 0) {
		log_error("%s:%d: Failed to send %d byte long packet over %s "
			  "interface.", MDL, client->packet_length,
			  client->interface->name);
	 }

    /*
     * If we used 0 microseconds here, and there were other clients on the
     * same network with a synchronized local clock (ntp), and a similar
     * zero-microsecond-scheduler behavior, then we could be participating
     * in a sub-second DOS ttck.
     */
    tv.tv_sec = cur_tv.tv_sec + client->interval;
    tv.tv_usec = client->interval > 1 ? random() % 1000000 : cur_tv.tv_usec;
    add_timeout(&tv, send_discover, client, 0, 0);
}

/* state_panic gets called if we haven't received any offers in a preset
   amount of time.   When this happens, we try to use existing leases that
   haven't yet expired, and failing that, we call the client script and
   hope it can do something. */

void state_panic (cpp)
    void *cpp;
{
    struct client_state *client = cpp;
    struct client_lease *loop;
    struct client_lease *lp;
    struct timeval tv;

    loop = lp = client -> active;

    log_info ("No DHCPOFFERS received.");

    /* We may not have an active lease, but we may have some
       predefined leases that we can try. */
    if (!client -> active && client -> leases)
        goto activate_next;

    /* Run through the list of leases and see if one can be used. */
    while (client -> active) {
        if (client -> active -> expiry > cur_time) {
            log_info ("Trying recorded lease %s",
                piaddr (client -> active -> address));
            /* Run the client script with the existing
               parameters. */
            script_init (client, "TIMEOUT",
                client -> active -> medium);
            script_write_params (client, "new_", client -> active);
            if (client -> alias)
                script_write_params (client, "alias_",
                    client -> alias);

            /* If the old lease is still good and doesn't
               yet need renewal, go into BOUND state and
               timeout at the renewal time. */
            if (!script_go (client)) {
                if (cur_time < client -> active -> renewal) {
                    client -> state = S_BOUND;
                    log_info ("bound: renewal in %ld %s.",
                        (long)(client -> active -> renewal -
                            cur_time), "seconds");
                    tv.tv_sec = client->active->renewal;
                    tv.tv_usec = ((client->active->renewal -
                            cur_time) > 1) ?
                        random() % 1000000 :
                        cur_tv.tv_usec;
                    add_timeout(&tv, state_bound, client, 0, 0);
                } else {
                    client -> state = S_BOUND;
                    log_info ("bound: immediate renewal.");
                    state_bound (client);
                }
                reinitialize_interfaces ();
                go_daemon ();
                return;
            }
        }

        /* If there are no other leases, give up. */
        if (!client -> leases) {
            client -> leases = client -> active;
            client -> active = (struct client_lease *)0;
            break;
        }

activate_next:
        /* Otherwise, put the active lease at the end of the
           lease list, and try another lease.. */
        for (lp = client -> leases; lp -> next; lp = lp -> next)
            ;
        lp -> next = client -> active;
        if (lp -> next) {
            lp -> next -> next = (struct client_lease *)0;
        }
        client -> active = client -> leases;
        client -> leases = client -> leases -> next;

        /* If we already tried this lease, we've exhausted the
           set of leases, so we might as well give up for
           now. */
        if (client -> active == loop)
            break;
        else if (!loop)
            loop = client -> active;
    }

    /* No leases were available, or what was available didn't work, so
       tell the shell script that we failed to allocate an address,
       and try again later. */
    if (onetry) {
        if (!quiet)
            log_info ("Unable to obtain a lease on first try.%s",
                "  Exiting.");
        //TODO lidong add, never do here in generally.
        client->hw_errcode = DHCP_DISCOVER_TIMEDOUT;
        script_init (client, "FAIL", 0);
        script_go (client);
        exit (2);
    }

    //TODO lidong add.
    if (client->config->hw_retry_times > 0) {
        DHCP_LOG_INFO("retry[%d] / sum[%d]\n", client->hw_cur_try + 1, client->config->hw_retry_times);
        if (client->hw_cur_try + 1 < client->config->hw_retry_times) {
            state_init (client);
            client->hw_cur_try++;
        } else {
            client->hw_errcode = DHCP_DISCOVER_TIMEDOUT;
            script_init (client, "FAIL", 0);
            script_go (client);
            exit (2);
        }
    } else {
        //if hw_retry_times = 0, infinite sequence backgroud.
        client->hw_errcode = DHCP_DISCOVER_TIMEDOUT;
        script_init (client, "FAIL", (struct string_list *)0);
        if (client -> alias)
            script_write_params (client, "alias_", client -> alias);
        script_go (client);
        client -> state = S_INIT;
        log_info ("No working leases in persistent database - sleeping.");
        tv.tv_sec = cur_tv.tv_sec + ((client->config->retry_interval + 1) / 2 +
            (random() % client->config->retry_interval));
        tv.tv_usec = ((tv.tv_sec - cur_tv.tv_sec) > 1) ?
            random() % 1000000 : cur_tv.tv_usec;
        add_timeout(&tv, state_init, client, 0, 0);
        go_daemon ();
    }
}

void send_request (cpp)
    void *cpp;
{
    struct client_state *client = cpp;

    int result;
    int interval;
    struct sockaddr_in destination;
    struct in_addr from;
    struct timeval tv;

    /* Figure out how long it's been since we started transmitting. */
    interval = cur_time - client -> first_sending;

    /* If we're in the INIT-REBOOT or REQUESTING state and we're
       past the reboot timeout, go to INIT and see if we can
       DISCOVER an address... */
    /* XXX In the INIT-REBOOT state, if we don't get an ACK, it
       means either that we're on a network with no DHCP server,
       or that our server is down.  In the latter case, assuming
       that there is a backup DHCP server, DHCPDISCOVER will get
       us a new address, but we could also have successfully
       reused our old address.  In the former case, we're hosed
       anyway.  This is not a win-prone situation. */
    if ((client -> state == S_REBOOTING ||
            client -> state == S_REQUESTING) &&
        interval > client -> config -> reboot_timeout) {
cancel:
        client -> state = S_INIT;
        cancel_timeout (send_request, client);
        state_init (client);
        return;
    }

    /* If we're in the reboot state, make sure the media is set up
       correctly. */
    if (client -> state == S_REBOOTING &&
        !client -> medium &&
        client -> active -> medium ) {
        script_init (client, "MEDIUM", client -> active -> medium);

        /* If the medium we chose won't fly, go to INIT state. */
        if (script_go (client))
            goto cancel;

        /* Record the medium. */
        client -> medium = client -> active -> medium;
    }

    /* If the lease has expired, relinquish the address and go back
       to the INIT state. */
    if (client -> state != S_REQUESTING &&
        cur_time > client -> active -> expiry) {
        /* Run the client script with the new parameters. */
        script_init (client, "EXPIRE", (struct string_list *)0);
        script_write_params (client, "old_", client -> active);
        if (client -> alias)
            script_write_params (client, "alias_",
                client -> alias);
        script_go (client);

        /* Now do a preinit on the interface so that we can
           discover a new address. */
        script_init (client, "PREINIT", (struct string_list *)0);
        if (client -> alias)
            script_write_params (client, "alias_",
                client -> alias);
        script_go (client);

        client -> state = S_INIT;
        state_init (client);
        return;
    }

    //TODO lidong add.
    float* leaseseq = &client->config->hw_leasetime_seq[0];
    if ((client -> state == S_RENEWING || client -> state == S_REBINDING) 
        && *leaseseq > 0 && client->hw_cur_idx < *leaseseq) {
        leaseseq++;
        client -> interval = client->hw_expiry * (leaseseq[client->hw_cur_idx] - leaseseq[client->hw_cur_idx - 1]);
        client->hw_cur_idx++; 
    } else {
        /* Do the exponential backoff... */
        if (!client -> interval)
            client -> interval = client -> config -> initial_interval;
        else 
            client -> interval += ((random () >> 2) %
                (2 * client -> interval));

        /* Don't backoff past cutoff. */
        if (client -> interval >
            client -> config -> backoff_cutoff)
            client -> interval =
                ((client -> config -> backoff_cutoff / 2)
                 + ((random () >> 2) %
                     client -> config -> backoff_cutoff));
    }

    /* If the backoff would take us to the expiry time, just set the
       timeout to the expiry time. */   
    if (client -> state != S_REQUESTING &&
        cur_time + client -> interval > client -> active -> expiry)
        client -> interval = client -> active -> expiry - cur_time + 1;

    /* If the lease T2 time has elapsed, or if we're not yet bound,
       broadcast the DHCPREQUEST rather than unicasting. */
    if (client -> state == S_REQUESTING ||
        client -> state == S_REBOOTING ||
        cur_time >= client -> active -> rebind)
        destination.sin_addr = sockaddr_broadcast.sin_addr;
    else
        memcpy (&destination.sin_addr.s_addr,
            client -> destination.iabuf,
            sizeof destination.sin_addr.s_addr);
    destination.sin_port = remote_port;
    destination.sin_family = AF_INET;
#ifdef HAVE_SA_LEN
    destination.sin_len = sizeof destination;
#endif

    if (client -> state == S_RENEWING ||
        client -> state == S_REBINDING)
        memcpy (&from, client -> active -> address.iabuf,
            sizeof from);
    else
        from.s_addr = INADDR_ANY;

    /* Record the number of seconds since we started sending. */
    if (client -> state == S_REQUESTING)
        client -> packet.secs = client -> secs;
    else {
        if (interval < 65536)
            client -> packet.secs = htons (interval);
        else
            client -> packet.secs = htons (65535);
    }

    log_info ("DHCPREQUEST on %s to %s port %d",
        client -> name ? client -> name : client -> interface -> name,
        inet_ntoa (destination.sin_addr),
        ntohs (destination.sin_port));

    if (destination.sin_addr.s_addr != INADDR_BROADCAST &&
        fallback_interface) {
        result = send_packet (fallback_interface,
            (struct packet *)0,
            &client -> packet,
            client -> packet_length,
            from, &destination,
            (struct hardware *)0);
        if (result < 0) {
            log_error("%s:%d: Failed to send %d byte long packet "
                "over %s interface.", MDL,
                client->packet_length,
                fallback_interface->name);
        }
    } else {
        /* Send out a packet. */
        result = send_packet (client -> interface, (struct packet *)0,
            &client -> packet,
            client -> packet_length,
            from, &destination,
            (struct hardware *)0);
        if (result < 0) {
            log_error("%s:%d: Failed to send %d byte long packet"
                " over %s interface.", MDL,
                client->packet_length,
                client->interface->name);
        }
    }

    tv.tv_sec = cur_tv.tv_sec + client->interval;
    tv.tv_usec = ((tv.tv_sec - cur_tv.tv_sec) > 1) ?
        random() % 1000000 : cur_tv.tv_usec;
    add_timeout(&tv, send_request, client, 0, 0);
}

void send_decline (cpp)
    void *cpp;
{
    struct client_state *client = cpp;

    int result;

    log_info ("DHCPDECLINE on %s to %s port %d",
        client -> name ? client -> name : client -> interface -> name,
        inet_ntoa (sockaddr_broadcast.sin_addr),
        ntohs (sockaddr_broadcast.sin_port));

    /* Send out a packet. */
    result = send_packet (client -> interface, (struct packet *)0,
        &client -> packet,
        client -> packet_length,
        inaddr_any, &sockaddr_broadcast,
        (struct hardware *)0);
    if (result < 0) {
        log_error("%s:%d: Failed to send %d byte long packet over %s"
            " interface.", MDL, client->packet_length,
            client->interface->name);
    }
}

void send_release (cpp)
    void *cpp;
{
    struct client_state *client = cpp;

    int result;
    struct sockaddr_in destination;
    struct in_addr from;

    memcpy (&from, client -> active -> address.iabuf,
        sizeof from);
    memcpy (&destination.sin_addr.s_addr,
        client -> destination.iabuf,
        sizeof destination.sin_addr.s_addr);
    destination.sin_port = remote_port;
    destination.sin_family = AF_INET;
#ifdef HAVE_SA_LEN
    destination.sin_len = sizeof destination;
#endif

    /* Set the lease to end now, so that we don't accidentally
       reuse it if we restart before the old expiry time. */
    client -> active -> expiry =
        client -> active -> renewal =
        client -> active -> rebind = cur_time;
    if (!write_client_lease (client, client -> active, 1, 1)) {
        log_error ("Can't release lease: lease write failed.");
        return;
    }

    log_info ("DHCPRELEASE on %s to %s port %d",
        client -> name ? client -> name : client -> interface -> name,
        inet_ntoa (destination.sin_addr),
        ntohs (destination.sin_port));

    if (fallback_interface) {
        /* Send out a packet. */
        result = send_packet (fallback_interface,
            (struct packet *)0,
            &client -> packet,
            client -> packet_length,
            from, &destination,
            (struct hardware *)0);
        if (result < 0) {
            log_error("%s:%d: Failed to send %d byte long packet"
                " over %s interface.", MDL,
                client->packet_length,
                fallback_interface->name);
        }
    } else {
        /* Send out a packet. */
        result = send_packet (client -> interface, (struct packet *)0,
            &client -> packet,
            client -> packet_length,
            from, &destination,
            (struct hardware *)0);
        if (result < 0) {
            log_error ("%s:%d: Failed to send %d byte long packet"
                " over %s interface.", MDL,
                client->packet_length,
                client->interface->name);
        }
    }
}

void
make_client_options(struct client_state *client, struct client_lease *lease,
    u_int8_t *type, struct option_cache *sid,
    struct iaddr *rip, struct option **prl,
    struct option_state **op)
{
    unsigned i;
    struct option_cache *oc;
    struct option *option = NULL;
    struct buffer *bp = (struct buffer *)0;

    /* If there are any leftover options, get rid of them. */
    if (*op)
        option_state_dereference (op, MDL);

    /* Allocate space for options. */
    option_state_allocate (op, MDL);

    /* Send the server identifier if provided. */
    if (sid)
        save_option (&dhcp_universe, *op, sid);

    oc = (struct option_cache *)0;

    /* Send the requested address if provided. */
    if (rip) {
        client -> requested_address = *rip;
        i = DHO_DHCP_REQUESTED_ADDRESS;
        if (!(option_code_hash_lookup(&option, dhcp_universe.code_hash,
                    &i, 0, MDL) &&
                make_const_option_cache(&oc, NULL, rip->iabuf, rip->len,
                    option, MDL)))
            log_error ("can't make requested address cache.");
        else {
            save_option (&dhcp_universe, *op, oc);
            option_cache_dereference (&oc, MDL);
        }
        option_dereference(&option, MDL);
    } else {
        client -> requested_address.len = 0;
    }

    i = DHO_DHCP_MESSAGE_TYPE;
    if (!(option_code_hash_lookup(&option, dhcp_universe.code_hash, &i, 0,
                MDL) &&
            make_const_option_cache(&oc, NULL, type, 1, option, MDL)))
        log_error ("can't make message type.");
    else {
        save_option (&dhcp_universe, *op, oc);
        option_cache_dereference (&oc, MDL);
    }
    option_dereference(&option, MDL);

    if (prl) {
        int len;

        /* Probe the length of the list. */
        len = 0;
        for (i = 0 ; prl[i] != NULL ; i++)
            if (prl[i]->universe == &dhcp_universe)
                len++;

        if (!buffer_allocate (&bp, len, MDL))
            log_error ("can't make parameter list buffer.");
        else {
            unsigned code = DHO_DHCP_PARAMETER_REQUEST_LIST;

            len = 0;
            for (i = 0 ; prl[i] != NULL ; i++)
                if (prl[i]->universe == &dhcp_universe)
                    bp->data[len++] = prl[i]->code;

            if (!(option_code_hash_lookup(&option,
                        dhcp_universe.code_hash,
                        &code, 0, MDL) &&
                    make_const_option_cache(&oc, &bp, NULL, len,
                        option, MDL)))
                log_error ("can't make option cache");
            else {
                save_option (&dhcp_universe, *op, oc);
                option_cache_dereference (&oc, MDL);
            }
            option_dereference(&option, MDL);
        }
    }

    /* Run statements that need to be run on transmission. */
    if (client -> config -> on_transmission)
        execute_statements_in_scope
            ((struct binding_value **)0,
             (struct packet *)0, (struct lease *)0, client,
             (lease ? lease -> options : (struct option_state *)0),
             *op, &global_scope,
             client -> config -> on_transmission,
             (struct group *)0);
}

void make_discover (client, lease)
    struct client_state *client;
    struct client_lease *lease;
{
    long int xid = random ();
    unsigned char discover = DHCPDISCOVER;
    struct option_state *options = (struct option_state *)0;

    memset (&client -> packet, 0, sizeof (client -> packet));

    make_client_options (client,
        lease, &discover, (struct option_cache *)0,
        lease ? &lease -> address : (struct iaddr *)0,
        client -> config -> requested_options,
        &options);

    //TODO for hw option60.
    if (client->config->hw_username && client->config->hw_password) {
        char value[1024] = { 0 };
        hw_generate_option60(value, client->config->hw_username, client->config->hw_password, client->config->hw_enterprise, xid);
        add_option(options, DHO_VENDOR_CLASS_IDENTIFIER /* 60 */, value, strlen(value));
    }

    /* Set up the option buffer... */
    client -> packet_length =
        cons_options ((struct packet *)0, &client -> packet,
            (struct lease *)0, client,
            /* maximum packet size */1500,
            (struct option_state *)0,
            options,
            /* scope */ &global_scope,
            /* overload */ 0,
            /* terminate */0,
            /* bootpp    */0,
            (struct data_string *)0,
            client -> config -> vendor_space_name);

    option_state_dereference (&options, MDL);
    if (client -> packet_length < BOOTP_MIN_LEN)
        client -> packet_length = BOOTP_MIN_LEN;

    client -> packet.op = BOOTREQUEST;
    client -> packet.htype = client -> interface -> hw_address.hbuf [0];
    client -> packet.hlen = client -> interface -> hw_address.hlen - 1;
    client -> packet.hops = 0;
    client -> packet.xid = xid; //random ();
    client -> packet.secs = 0; /* filled in by send_discover. */

    if (can_receive_unicast_unconfigured (client -> interface))
        client -> packet.flags = 0;
    else
        client -> packet.flags = htons (BOOTP_BROADCAST);

    memset (&(client -> packet.ciaddr),
        0, sizeof client -> packet.ciaddr);
    memset (&(client -> packet.yiaddr),
        0, sizeof client -> packet.yiaddr);
    memset (&(client -> packet.siaddr),
        0, sizeof client -> packet.siaddr);
    client -> packet.giaddr = giaddr;
    if (client -> interface -> hw_address.hlen > 0)
        memcpy (client -> packet.chaddr,
            &client -> interface -> hw_address.hbuf [1],
            (unsigned)(client -> interface -> hw_address.hlen - 1));

#ifdef DEBUG_PACKET
    dump_raw ((unsigned char *)&client -> packet, client -> packet_length);
#endif
}


void make_request (client, lease)
    struct client_state *client;
    struct client_lease *lease;
{
    unsigned char request = DHCPREQUEST;
    struct option_cache *oc;

    memset (&client -> packet, 0, sizeof (client -> packet));

    if (client -> state == S_REQUESTING)
        oc = lookup_option (&dhcp_universe, lease -> options,
            DHO_DHCP_SERVER_IDENTIFIER);
    else
        oc = (struct option_cache *)0;

    if (client -> sent_options)
        option_state_dereference (&client -> sent_options, MDL);

    make_client_options (client, lease, &request, oc,
        ((client -> state == S_REQUESTING ||
          client -> state == S_REBOOTING)
         ? &lease -> address
         : (struct iaddr *)0),
        client -> config -> requested_options,
        &client -> sent_options);

    /* Set up the option buffer... */
    client -> packet_length =
        cons_options ((struct packet *)0, &client -> packet,
            (struct lease *)0, client,
            /* maximum packet size */1500,
            (struct option_state *)0,
            client -> sent_options,
            /* scope */ &global_scope,
            /* overload */ 0,
            /* terminate */0,
            /* bootpp    */0,
            (struct data_string *)0,
            client -> config -> vendor_space_name);

    if (client -> packet_length < BOOTP_MIN_LEN)
        client -> packet_length = BOOTP_MIN_LEN;

    client -> packet.op = BOOTREQUEST;
    client -> packet.htype = client -> interface -> hw_address.hbuf [0];
    client -> packet.hlen = client -> interface -> hw_address.hlen - 1;
    client -> packet.hops = 0;
    client -> packet.xid = client -> xid;
    client -> packet.secs = 0; /* Filled in by send_request. */

    /* If we own the address we're requesting, put it in ciaddr;
       otherwise set ciaddr to zero. */
    if (client -> state == S_BOUND ||
        client -> state == S_RENEWING ||
        client -> state == S_REBINDING) {
        memcpy (&client -> packet.ciaddr,
            lease -> address.iabuf, lease -> address.len);
        client -> packet.flags = 0;
    } else {
        memset (&client -> packet.ciaddr, 0,
            sizeof client -> packet.ciaddr);
        if (can_receive_unicast_unconfigured (client -> interface))
            client -> packet.flags = 0;
        else
            client -> packet.flags = htons (BOOTP_BROADCAST);
    }

    memset (&client -> packet.yiaddr, 0,
        sizeof client -> packet.yiaddr);
    memset (&client -> packet.siaddr, 0,
        sizeof client -> packet.siaddr);
    if (client -> state != S_BOUND &&
        client -> state != S_RENEWING)
        client -> packet.giaddr = giaddr;
    else
        memset (&client -> packet.giaddr, 0,
            sizeof client -> packet.giaddr);
    if (client -> interface -> hw_address.hlen > 0)
        memcpy (client -> packet.chaddr,
            &client -> interface -> hw_address.hbuf [1],
            (unsigned)(client -> interface -> hw_address.hlen - 1));

#ifdef DEBUG_PACKET
    dump_raw ((unsigned char *)&client -> packet, client -> packet_length);
#endif
}

void make_decline (client, lease)
    struct client_state *client;
    struct client_lease *lease;
{
    unsigned char decline = DHCPDECLINE;
    struct option_cache *oc;

    struct option_state *options = (struct option_state *)0;

    /* Create the options cache. */
    oc = lookup_option (&dhcp_universe, lease -> options,
        DHO_DHCP_SERVER_IDENTIFIER);
    make_client_options(client, lease, &decline, oc, &lease->address,
        NULL, &options);

    /* Consume the options cache into the option buffer. */
    memset (&client -> packet, 0, sizeof (client -> packet));
    client -> packet_length =
        cons_options ((struct packet *)0, &client -> packet,
            (struct lease *)0, client, 0,
            (struct option_state *)0, options,
            &global_scope, 0, 0, 0, (struct data_string *)0,
            client -> config -> vendor_space_name);

    /* Destroy the options cache. */
    option_state_dereference (&options, MDL);

    if (client -> packet_length < BOOTP_MIN_LEN)
        client -> packet_length = BOOTP_MIN_LEN;

    client -> packet.op = BOOTREQUEST;
    client -> packet.htype = client -> interface -> hw_address.hbuf [0];
    client -> packet.hlen = client -> interface -> hw_address.hlen - 1;
    client -> packet.hops = 0;
    client -> packet.xid = client -> xid;
    client -> packet.secs = 0; /* Filled in by send_request. */
    if (can_receive_unicast_unconfigured (client -> interface))
        client -> packet.flags = 0;
    else
        client -> packet.flags = htons (BOOTP_BROADCAST);

    /* ciaddr must always be zero. */
    memset (&client -> packet.ciaddr, 0,
        sizeof client -> packet.ciaddr);
    memset (&client -> packet.yiaddr, 0,
        sizeof client -> packet.yiaddr);
    memset (&client -> packet.siaddr, 0,
        sizeof client -> packet.siaddr);
    client -> packet.giaddr = giaddr;
    memcpy (client -> packet.chaddr,
        &client -> interface -> hw_address.hbuf [1],
        client -> interface -> hw_address.hlen);

#ifdef DEBUG_PACKET
    dump_raw ((unsigned char *)&client -> packet, client -> packet_length);
#endif
}

void make_release (client, lease)
    struct client_state *client;
    struct client_lease *lease;
{
    unsigned char request = DHCPRELEASE;
    struct option_cache *oc;

    struct option_state *options = (struct option_state *)0;

    memset (&client -> packet, 0, sizeof (client -> packet));

    oc = lookup_option (&dhcp_universe, lease -> options,
        DHO_DHCP_SERVER_IDENTIFIER);
    make_client_options(client, lease, &request, oc, NULL, NULL, &options);

    /* Set up the option buffer... */
    client -> packet_length =
        cons_options ((struct packet *)0, &client -> packet,
            (struct lease *)0, client,
            /* maximum packet size */1500,
            (struct option_state *)0,
            options,
            /* scope */ &global_scope,
            /* overload */ 0,
            /* terminate */0,
            /* bootpp    */0,
            (struct data_string *)0,
            client -> config -> vendor_space_name);

    if (client -> packet_length < BOOTP_MIN_LEN)
        client -> packet_length = BOOTP_MIN_LEN;
    option_state_dereference (&options, MDL);

    client -> packet.op = BOOTREQUEST;
    client -> packet.htype = client -> interface -> hw_address.hbuf [0];
    client -> packet.hlen = client -> interface -> hw_address.hlen - 1;
    client -> packet.hops = 0;
    client -> packet.xid = random ();
    client -> packet.secs = 0;
    client -> packet.flags = 0;
    memcpy (&client -> packet.ciaddr,
        lease -> address.iabuf, lease -> address.len);
    memset (&client -> packet.yiaddr, 0,
        sizeof client -> packet.yiaddr);
    memset (&client -> packet.siaddr, 0,
        sizeof client -> packet.siaddr);
    client -> packet.giaddr = giaddr;
    memcpy (client -> packet.chaddr,
        &client -> interface -> hw_address.hbuf [1],
        client -> interface -> hw_address.hlen);

#ifdef DEBUG_PACKET
    dump_raw ((unsigned char *)&client -> packet, client -> packet_length);
#endif
}

void destroy_client_lease (lease)
    struct client_lease *lease;
{
    if (lease -> server_name)
        dfree (lease -> server_name, MDL);
    if (lease -> filename)
        dfree (lease -> filename, MDL);
    option_state_dereference (&lease -> options, MDL);
    free_client_lease (lease, MDL);
}

FILE *leaseFile = NULL;
int leases_written = 0;

void rewrite_client_leases ()
{
    struct interface_info *ip;
    struct client_state *client;
    struct client_lease *lp;

    if (leaseFile != NULL)
        fclose (leaseFile);
    leaseFile = fopen (path_dhclient_db, "w");
    if (leaseFile == NULL) {
        log_error ("can't create %s: %m", path_dhclient_db);
        return;
    }

    /* If there is a default duid, write it out. */
    if (default_duid.len != 0)
        write_duid(&default_duid);

    /* Write out all the leases attached to configured interfaces that
       we know about. */
    for (ip = interfaces; ip; ip = ip -> next) {
        for (client = ip -> client; client; client = client -> next) {
            for (lp = client -> leases; lp; lp = lp -> next) {
                write_client_lease (client, lp, 1, 0);
            }
            if (client -> active)
                write_client_lease (client,
                    client -> active, 1, 0);

            if (client->active_lease != NULL)
                write_client6_lease(client,
                    client->active_lease,
                    1, 0);

            /* Reset last_write after rewrites. */
            client->last_write = 0;
        }
    }

    /* Write out any leases that are attached to interfaces that aren't
       currently configured. */
    for (ip = dummy_interfaces; ip; ip = ip -> next) {
        for (client = ip -> client; client; client = client -> next) {
            for (lp = client -> leases; lp; lp = lp -> next) {
                write_client_lease (client, lp, 1, 0);
            }
            if (client -> active)
                write_client_lease (client,
                    client -> active, 1, 0);

            if (client->active_lease != NULL)
                write_client6_lease(client,
                    client->active_lease,
                    1, 0);

            /* Reset last_write after rewrites. */
            client->last_write = 0;
        }
    }
    fflush (leaseFile);
}

void write_lease_option (struct option_cache *oc,
    struct packet *packet, struct lease *lease,
    struct client_state *client_state,
    struct option_state *in_options,
    struct option_state *cfg_options,
    struct binding_scope **scope,
    struct universe *u, void *stuff)
{
    const char *name, *dot;
    struct data_string ds;
    char *preamble = stuff;

    memset (&ds, 0, sizeof ds);

    if (u != &dhcp_universe) {
        name = u -> name;
        dot = ".";
    } else {
        name = "";
        dot = "";
    }
    if (evaluate_option_cache (&ds, packet, lease, client_state,
            in_options, cfg_options, scope, oc, MDL)) {
        fprintf(leaseFile, "%soption %s%s%s", preamble,
            name, dot, oc->option->name);

        /* The option value if there is one */
        if ((oc->option->format == NULL) ||
            (oc->option->format[0] != 'Z')) {
            fprintf(leaseFile, " %s",
                pretty_print_option(oc->option, ds.data,
                    ds.len, 1, 1));
        }

        /* The closing semi-colon and newline */
        fprintf(leaseFile, ";\n");

        data_string_forget (&ds, MDL);
    }
}

/* Write an option cache to the lease store. */
static void
write_options(struct client_state *client, struct option_state *options,
    const char *preamble)
{
    int i;

    for (i = 0; i < options->universe_count; i++) {
        option_space_foreach(NULL, NULL, client, NULL, options,
            &global_scope, universes[i],
            (char *)preamble, write_lease_option);
    }
}

/* Write the default DUID to the lease store. */
static isc_result_t
write_duid(struct data_string *duid)
{
    char *str;
    int stat;

    if ((duid == NULL) || (duid->len <= 2))
        return ISC_R_INVALIDARG;

    if (leaseFile == NULL) {	/* XXX? */
        leaseFile = fopen(path_dhclient_db, "w");
        if (leaseFile == NULL) {
            log_error("can't create %s: %m", path_dhclient_db);
            return ISC_R_IOERROR;
        }
    }

    /* It would make more sense to write this as a hex string,
     * but our function to do that (print_hex_n) uses a fixed
     * length buffer...and we can't guarantee a duid would be
     * less than the fixed length.
     */
    str = quotify_buf(duid->data, duid->len, MDL);
    if (str == NULL)
        return ISC_R_NOMEMORY;

    stat = fprintf(leaseFile, "default-duid \"%s\";\n", str);
    dfree(str, MDL);
    if (stat <= 0)
        return ISC_R_IOERROR;

    if (fflush(leaseFile) != 0)
        return ISC_R_IOERROR;

    return ISC_R_SUCCESS;
}

/* Write a DHCPv6 lease to the store. */
isc_result_t
write_client6_lease(struct client_state *client, struct dhc6_lease *lease,
    int rewrite, int sync)
{
    struct dhc6_ia *ia;
    struct dhc6_addr *addr;
    int stat;
    const char *ianame;

    /* This should include the current lease. */
    if (!rewrite && (leases_written++ > 20)) {
        rewrite_client_leases();
        leases_written = 0;
        return ISC_R_SUCCESS;
    }

    if (client == NULL || lease == NULL)
        return ISC_R_INVALIDARG;

    if (leaseFile == NULL) {	/* XXX? */
        leaseFile = fopen(path_dhclient_db, "w");
        if (leaseFile == NULL) {
            log_error("can't create %s: %m", path_dhclient_db);
            return ISC_R_IOERROR;
        }
    }

    stat = fprintf(leaseFile, "lease6 {\n");
    if (stat <= 0)
        return ISC_R_IOERROR;

    stat = fprintf(leaseFile, "  interface \"%s\";\n",
        client->interface->name);
    if (stat <= 0)
        return ISC_R_IOERROR;

    for (ia = lease->bindings ; ia != NULL ; ia = ia->next) {
        switch (ia->ia_type) {
        case D6O_IA_NA:
        default:
            ianame = "ia-na";
            break;
        case D6O_IA_TA:
            ianame = "ia-ta";
            break;
        case D6O_IA_PD:
            ianame = "ia-pd";
            break;
        }
        stat = fprintf(leaseFile, "  %s %s {\n",
            ianame, print_hex_1(4, ia->iaid, 12));
        if (stat <= 0)
            return ISC_R_IOERROR;

        if (ia->ia_type != D6O_IA_TA)
            stat = fprintf(leaseFile, "    starts %d;\n"
                "    renew %u;\n"
                "    rebind %u;\n",
                (int)ia->starts, ia->renew, ia->rebind);
        else
            stat = fprintf(leaseFile, "    starts %d;\n",
                (int)ia->starts);
        if (stat <= 0)
            return ISC_R_IOERROR;

        for (addr = ia->addrs ; addr != NULL ; addr = addr->next) {
            if (ia->ia_type != D6O_IA_PD)
                stat = fprintf(leaseFile,
                    "    iaaddr %s {\n",
                    piaddr(addr->address));
            else
                stat = fprintf(leaseFile,
                    "    iaprefix %s/%d {\n",
                    piaddr(addr->address),
                    (int)addr->plen);
            if (stat <= 0)
                return ISC_R_IOERROR;

            stat = fprintf(leaseFile, "      starts %d;\n"
                "      preferred-life %u;\n"
                "      max-life %u;\n",
                (int)addr->starts, addr->preferred_life,
                addr->max_life);
            if (stat <= 0)
                return ISC_R_IOERROR;

            if (addr->options != NULL)
                write_options(client, addr->options, "      ");

            stat = fprintf(leaseFile, "    }\n");
            if (stat <= 0)
                return ISC_R_IOERROR;
        }

        if (ia->options != NULL)
            write_options(client, ia->options, "    ");

        stat = fprintf(leaseFile, "  }\n");
        if (stat <= 0)
            return ISC_R_IOERROR;
    }

    if (lease->released) {
        stat = fprintf(leaseFile, "  released;\n");
        if (stat <= 0)
            return ISC_R_IOERROR;
    }

    if (lease->options != NULL)
        write_options(client, lease->options, "  ");

    stat = fprintf(leaseFile, "}\n");
    if (stat <= 0)
        return ISC_R_IOERROR;

    if (fflush(leaseFile) != 0)
        return ISC_R_IOERROR;

    if (sync) {
        if (fsync(fileno(leaseFile)) < 0) {
            log_error("write_client_lease: fsync(): %m");
            return ISC_R_IOERROR;
        }
    }

    return ISC_R_SUCCESS;
}

int write_client_lease (client, lease, rewrite, makesure)
    struct client_state *client;
    struct client_lease *lease;
    int rewrite;
    int makesure;
{
    struct data_string ds;
    int errors = 0;
    char *s;
    const char *tval;

    if (!rewrite) {
        if (leases_written++ > 20) {
            rewrite_client_leases ();
            leases_written = 0;
        }
    }

    /* If the lease came from the config file, we don't need to stash
       a copy in the lease database. */
    if (lease -> is_static)
        return 1;

    if (leaseFile == NULL) {	/* XXX */
        leaseFile = fopen (path_dhclient_db, "w");
        if (leaseFile == NULL) {
            log_error ("can't create %s: %m", path_dhclient_db);
            return 0;
        }
    }

    errno = 0;
    fprintf (leaseFile, "lease {\n");
    if (lease -> is_bootp) {
        fprintf (leaseFile, "  bootp;\n");
        if (errno) {
            ++errors;
            errno = 0;
        }
    }
    fprintf (leaseFile, "  interface \"%s\";\n",
        client -> interface -> name);
    if (errno) {
        ++errors;
        errno = 0;
    }
    if (client -> name) {
        fprintf (leaseFile, "  name \"%s\";\n", client -> name);
        if (errno) {
            ++errors;
            errno = 0;
        }
    }
    fprintf (leaseFile, "  fixed-address %s;\n",
        piaddr (lease -> address));
    if (errno) {
        ++errors;
        errno = 0;
    }
    if (lease -> filename) {
        s = quotify_string (lease -> filename, MDL);
        if (s) {
            fprintf (leaseFile, "  filename \"%s\";\n", s);
            if (errno) {
                ++errors;
                errno = 0;
            }
            dfree (s, MDL);
        } else
            errors++;

    }
    if (lease->server_name != NULL) {
        s = quotify_string(lease->server_name, MDL);
        if (s != NULL) {
            fprintf(leaseFile, "  server-name \"%s\";\n", s);
            if (errno) {
                ++errors;
                errno = 0;
            }
            dfree(s, MDL);
        } else
            ++errors;
    }
    if (lease -> medium) {
        s = quotify_string (lease -> medium -> string, MDL);
        if (s) {
            fprintf (leaseFile, "  medium \"%s\";\n", s);
            if (errno) {
                ++errors;
                errno = 0;
            }
            dfree (s, MDL);
        } else
            errors++;
    }
    if (errno != 0) {
        errors++;
        errno = 0;
    }

    memset (&ds, 0, sizeof ds);

    write_options(client, lease->options, "  ");

    tval = print_time(lease->renewal);
    if (tval == NULL ||
        fprintf(leaseFile, "  renew %s\n", tval) < 0)
        errors++;

    tval = print_time(lease->rebind);
    if (tval == NULL ||
        fprintf(leaseFile, "  rebind %s\n", tval) < 0)
        errors++;

    tval = print_time(lease->expiry);
    if (tval == NULL ||
        fprintf(leaseFile, "  expire %s\n", tval) < 0)
        errors++;

    if (fprintf(leaseFile, "}\n") < 0)
        errors++;

    if (fflush(leaseFile) != 0)
        errors++;

    client->last_write = cur_time;

    if (!errors && makesure) {
        if (fsync (fileno (leaseFile)) < 0) {
            log_info ("write_client_lease: %m");
            return 0;
        }
    }

    return errors ? 0 : 1;
}

//LiDong add.
int write_fifo_message(client)
    struct client_state *client;
{
    char fifoname[128] = { 0 };
    int fifoval = client->hw_errcode > DHCP_ERRORCODE_BASE ? -1 : 1;
    if (-1 == gFifoFd) {
        sprintf(fifoname, "%s/dhclient-%s.pipe", DBDIR, client->interface->name);
        if ((mkfifo(fifoname, O_CREAT | O_EXCL) < 0) && (errno != EEXIST))
            DHCP_LOG_WARN("can not create fifo[%s]\n", fifoname);
        if ((gFifoFd = open(fifoname, O_WRONLY | O_NONBLOCK, 0)) < 0) { //3560E not support: O_CLOEXEC
            if (errno == ENXIO) {
                DHCP_LOG_ERROR("open[%s]:[%s]\n", fifoname, strerror(errno));
                return -1;
            }
        }
    }

    if (!client->hw_errcode)
        fifoval = 0;

    DHCP_LOG_INFO("write fifo val:%d\n", fifoval);
    if (write(gFifoFd, &fifoval, sizeof(int)) < 0) {
        if (errno == EAGAIN) {
            DHCP_LOG_ERROR("The FIFO has not been read yet. Please try later!\n");
            return -1;
        }
    }
    client->hw_errcode = 0; //Restore
    return 0;
}

/* Variables holding name of script and file pointer for writing to
   script.   Needless to say, this is not reentrant - only one script
   can be invoked at a time. */
char scriptName [256];
FILE *scriptFile;

void script_init (client, reason, medium)
    struct client_state *client;
    const char *reason;
    struct string_list *medium;
{
    struct string_list *sl, *next;

    if (client) {
        for (sl = client -> env; sl; sl = next) {
            next = sl -> next;
            dfree (sl, MDL);
        }
        client -> env = (struct string_list *)0;
        client -> envc = 0;

        if (client -> interface) {
            client_envadd (client, "", "interface", "%s",
                client -> interface -> name);
        }
        if (client -> name)
            client_envadd (client,
                "", "client", "%s", client -> name);
        if (medium)
            client_envadd (client,
                "", "medium", "%s", medium -> string);

        client_envadd (client, "", "reason", "%s", reason);
        client_envadd (client, "", "pid", "%ld", (long int)getpid ());
        client_envadd (client, "", "errcode", "%d", client -> hw_errcode);
    }
}

void client_option_envadd (struct option_cache *oc,
    struct packet *packet, struct lease *lease,
    struct client_state *client_state,
    struct option_state *in_options,
    struct option_state *cfg_options,
    struct binding_scope **scope,
    struct universe *u, void *stuff)
{
    struct envadd_state *es = stuff;
    struct data_string data;
    memset (&data, 0, sizeof data);

    if (evaluate_option_cache (&data, packet, lease, client_state,
            in_options, cfg_options, scope, oc, MDL)) {
        if (data.len) {
            char name [256];
            if (dhcp_option_ev_name (name, sizeof name,
                    oc->option)) {
                const char *value;
                value = pretty_print_option(oc->option,
                    data.data,
                    data.len, 0, 0);
                size_t length = strlen(value);

                if (check_option_values(oc->option->universe,
                        oc->option->code,
                        value, length) == 0) {
                    client_envadd(es->client, es->prefix,
                        name, "%s", value);
                } else {
                    log_error("suspect value in %s "
                        "option - discarded",
                        name);
                }
                data_string_forget (&data, MDL);
            }
        }
    }
}

void script_write_params (client, prefix, lease)
    struct client_state *client;
    const char *prefix;
    struct client_lease *lease;
{
    int i;
    struct data_string data;
    struct option_cache *oc;
    struct envadd_state es;

    es.client = client;
    es.prefix = prefix;

    client_envadd (client,
        prefix, "ip_address", "%s", piaddr (lease -> address));

    /* For the benefit of Linux (and operating systems which may
       have similar needs), compute the network address based on
       the supplied ip address and netmask, if provided.  Also
       compute the broadcast address (the host address all ones
       broadcast address, not the host address all zeroes
       broadcast address). */

    memset (&data, 0, sizeof data);
    oc = lookup_option (&dhcp_universe, lease -> options, DHO_SUBNET_MASK);
    if (oc && evaluate_option_cache (&data, (struct packet *)0,
            (struct lease *)0, client,
            (struct option_state *)0,
            lease -> options,
            &global_scope, oc, MDL)) {
        if (data.len > 3) {
            struct iaddr netmask, subnet, broadcast;

            /*
             * No matter the length of the subnet-mask option,
             * use only the first four octets.  Note that
             * subnet-mask options longer than 4 octets are not
             * in conformance with RFC 2132, but servers with this
             * flaw do exist.
             */
            memcpy(netmask.iabuf, data.data, 4);
            netmask.len = 4;
            data_string_forget (&data, MDL);

            subnet = subnet_number (lease -> address, netmask);
            if (subnet.len) {
                client_envadd (client, prefix, "network_number",
                    "%s", piaddr (subnet));

                oc = lookup_option (&dhcp_universe,
                    lease -> options,
                    DHO_BROADCAST_ADDRESS);
                if (!oc ||
                    !(evaluate_option_cache
                        (&data, (struct packet *)0,
                         (struct lease *)0, client,
                         (struct option_state *)0,
                         lease -> options,
                         &global_scope, oc, MDL))) {
                    broadcast = broadcast_addr (subnet, netmask);
                    if (broadcast.len) {
                        client_envadd (client,
                            prefix, "broadcast_address",
                            "%s", piaddr (broadcast));
                    }
                }
            }
        }
        data_string_forget (&data, MDL);
    }

    if (lease->filename) {
        if (check_option_values(NULL, DHO_ROOT_PATH,
                lease->filename,
                strlen(lease->filename)) == 0) {
            client_envadd(client, prefix, "filename",
                "%s", lease->filename);
        } else {
            log_error("suspect value in %s "
                "option - discarded",
                lease->filename);
        }
    }

    if (lease->server_name) {
        if (check_option_values(NULL, DHO_HOST_NAME,
                lease->server_name,
                strlen(lease->server_name)) == 0 ) {
            client_envadd (client, prefix, "server_name",
                "%s", lease->server_name);
        } else {
            log_error("suspect value in %s "
                "option - discarded",
                lease->server_name);
        }
    }


    for (i = 0; i < lease -> options -> universe_count; i++) {
        option_space_foreach ((struct packet *)0, (struct lease *)0,
            client, (struct option_state *)0,
            lease -> options, &global_scope,
            universes [i],
            &es, client_option_envadd);
    }
    client_envadd (client, prefix, "expiry", "%d", (int)(lease -> expiry));
}

int script_go (client)
    struct client_state *client;
{
    char *scriptName;
    char *argv [2];
    char **envp;
    char reason [] = "REASON=NBI";
    static char client_path [] = CLIENT_PATH;
    int i;
    struct string_list *sp, *next;
    int pid, wpid, wstatus;

    if (client)
        scriptName = client -> config -> script_name;
    else
        scriptName = top_level_config.script_name;

    envp = dmalloc (((client ? client -> envc : 2) +
            client_env_count + 2) * sizeof (char *), MDL);
    if (!envp) {
        log_error ("No memory for client script environment.");
        return 0;
    }
    i = 0;
    /* Copy out the environment specified on the command line,
       if any. */
    for (sp = client_env; sp; sp = sp -> next) {
        envp [i++] = sp -> string;
    }
    /* Copy out the environment specified by dhclient. */
    if (client) {
        for (sp = client -> env; sp; sp = sp -> next) {
            envp [i++] = sp -> string;
        }
    } else {
        envp [i++] = reason;
    }
    /* Set $PATH. */
    envp [i++] = client_path;
    envp [i] = (char *)0;

    argv [0] = scriptName;
    argv [1] = (char *)0;

    pid = fork ();
    if (pid < 0) {
        log_error ("fork: %m");
        wstatus = 0;
    } else if (pid) {
        do {
            wpid = wait (&wstatus);
        } while (wpid != pid && wpid > 0);
        if (wpid < 0) {
            log_error ("wait: %m");
            wstatus = 0;
        }
    } else {
        /* We don't want to pass an open file descriptor for
         * dhclient.leases when executing dhclient-script.
         */
        if (leaseFile != NULL)
            fclose(leaseFile);
        execve (scriptName, argv, envp);
        log_error ("execve (%s, ...): %m", scriptName);
        exit (0);
    }

    if (client) {
        //LiDong add.
        write_fifo_message(client);
        for (sp = client -> env; sp; sp = next) {
            next = sp -> next;
            dfree (sp, MDL);
        }
        client -> env = (struct string_list *)0;
        client -> envc = 0;
    }
    dfree (envp, MDL);
    //gettimeofday(&cur_tv, NULL);
    get_current_clocktime(&cur_tv, NULL); //TODO LiDong mod.
    return (WIFEXITED (wstatus) ?
        WEXITSTATUS (wstatus) : -WTERMSIG (wstatus));
}

void client_envadd (struct client_state *client,
    const char *prefix, const char *name, const char *fmt, ...)
{
    char spbuf [1024];
    char *s;
    unsigned len;
    struct string_list *val;
    va_list list;

    va_start (list, fmt);
    len = vsnprintf (spbuf, sizeof spbuf, fmt, list);
    va_end (list);

    val = dmalloc (strlen (prefix) + strlen (name) + 1 /* = */ +
        len + sizeof *val, MDL);
    if (!val)
        return;
    s = val -> string;
    strcpy (s, prefix);
    strcat (s, name);
    s += strlen (s);
    *s++ = '=';
    if (len >= sizeof spbuf) {
        va_start (list, fmt);
        vsnprintf (s, len + 1, fmt, list);
        va_end (list);
    } else
        strcpy (s, spbuf);
    val -> next = client -> env;
    client -> env = val;
    client -> envc++;
    DHCP_LOG_INFO("client envadd: %s\n", val->string);
}

int dhcp_option_ev_name (buf, buflen, option)
    char *buf;
    size_t buflen;
    struct option *option;
{
    int i, j;
    const char *s;

    j = 0;
    if (option -> universe != &dhcp_universe) {
        s = option -> universe -> name;
        i = 0;
    } else {
        s = option -> name;
        i = 1;
    }

    do {
        while (*s) {
            if (j + 1 == buflen)
                return 0;
            if (*s == '-')
                buf [j++] = '_';
            else
                buf [j++] = *s;
            ++s;
        }
        if (!i) {
            s = option -> name;
            if (j + 1 == buflen)
                return 0;
            buf [j++] = '_';
        }
        ++i;
    } while (i != 2);

    buf [j] = 0;
    return 1;
}

void go_daemon ()
{
    static int state = 0;
    int pid;

    /* Don't become a daemon if the user requested otherwise. */
    if (no_daemon) {
        write_client_pid_file ();
        return;
    }

    /* Only do it once. */
    if (state)
        return;
    state = 1;

    /* Stop logging to stderr... */
    log_perror = 0;

    /* Become a daemon... */
    if ((pid = fork ()) < 0)
        log_fatal ("Can't fork daemon: %m");
    else if (pid)
        exit (0);
    /* Become session leader and get pid... */
    pid = setsid ();

    /* Close standard I/O descriptors. */
    close(0);
    close(1);
    close(2);

    /* Reopen them on /dev/null. */
    open("/dev/null", O_RDWR);
    open("/dev/null", O_RDWR);
    open("/dev/null", O_RDWR);

    write_client_pid_file ();

    IGNORE_RET (chdir("/"));
}

void write_client_pid_file ()
{
    FILE *pf;
    int pfdesc;

    /* nothing to do if the user doesn't want a pid file */
    if (no_pid_file == ISC_TRUE) {
        return;
    }

    pfdesc = open (path_dhclient_pid, O_CREAT | O_TRUNC | O_WRONLY, 0644);

    if (pfdesc < 0) {
        log_error ("Can't create %s: %m", path_dhclient_pid);
        return;
    }

    pf = fdopen (pfdesc, "w");
    if (!pf) {
        close(pfdesc);
        log_error ("Can't fdopen %s: %m", path_dhclient_pid);
    } else {
        fprintf (pf, "%ld\n", (long)getpid ());
        fclose (pf);
    }
}

void client_location_changed ()
{
    struct interface_info *ip;
    struct client_state *client;

    for (ip = interfaces; ip; ip = ip -> next) {
        for (client = ip -> client; client; client = client -> next) {
            switch (client -> state) {
            case S_SELECTING:
                cancel_timeout (send_discover, client);
                break;

            case S_BOUND:
                cancel_timeout (state_bound, client);
                break;

            case S_REBOOTING:
            case S_REQUESTING:
            case S_RENEWING:
                cancel_timeout (send_request, client);
                break;

            case S_INIT:
            case S_REBINDING:
            case S_STOPPED:
                break;
            }
            client -> state = S_INIT;
            state_reboot (client);
        }
    }
}

void do_release(client)
    struct client_state *client;
{
    struct data_string ds;
    struct option_cache *oc;

    /* Pick a random xid. */
    client -> xid = random ();

    /* is there even a lease to release? */
    if (client -> active) {
        /* Make a DHCPRELEASE packet, and set appropriate per-interface
           flags. */
        make_release (client, client -> active);

        memset (&ds, 0, sizeof ds);
        oc = lookup_option (&dhcp_universe,
            client -> active -> options,
            DHO_DHCP_SERVER_IDENTIFIER);
        if (oc &&
            evaluate_option_cache (&ds, (struct packet *)0,
                (struct lease *)0, client,
                (struct option_state *)0,
                client -> active -> options,
                &global_scope, oc, MDL)) {
            if (ds.len > 3) {
                memcpy (client -> destination.iabuf,
                    ds.data, 4);
                client -> destination.len = 4;
            } else
                client -> destination = iaddr_broadcast;

            data_string_forget (&ds, MDL);
        } else
            client -> destination = iaddr_broadcast;
        client -> first_sending = cur_time;
        client -> interval = client -> config -> initial_interval;

        /* Zap the medium list... */
        client -> medium = (struct string_list *)0;

        /* Send out the first and only DHCPRELEASE packet. */
        send_release (client);

        /* Do the client script RELEASE operation. */
        script_init (client,
            "RELEASE", (struct string_list *)0);
        if (client -> alias)
            script_write_params (client, "alias_",
                client -> alias);
        script_write_params (client, "old_", client -> active);
        script_go (client);
    }

    /* Cancel any timeouts. */
    cancel_timeout (state_bound, client);
    cancel_timeout (send_discover, client);
    cancel_timeout (state_init, client);
    cancel_timeout (send_request, client);
    cancel_timeout (state_reboot, client);
    client -> state = S_STOPPED;
}

int dhclient_interface_shutdown_hook (struct interface_info *interface)
{
    do_release (interface -> client);

    return 1;
}

int dhclient_interface_discovery_hook (struct interface_info *tmp)
{
    struct interface_info *last, *ip;
    /* See if we can find the client from dummy_interfaces */
    last = 0;
    for (ip = dummy_interfaces; ip; ip = ip -> next) {
        if (!strcmp (ip -> name, tmp -> name)) {
            /* Remove from dummy_interfaces */
            if (last) {
                ip = (struct interface_info *)0;
                interface_reference (&ip, last -> next, MDL);
                interface_dereference (&last -> next, MDL);
                if (ip -> next) {
                    interface_reference (&last -> next,
                        ip -> next, MDL);
                    interface_dereference (&ip -> next,
                        MDL);
                }
            } else {
                ip = (struct interface_info *)0;
                interface_reference (&ip,
                    dummy_interfaces, MDL);
                interface_dereference (&dummy_interfaces, MDL);
                if (ip -> next) {
                    interface_reference (&dummy_interfaces,
                        ip -> next, MDL);
                    interface_dereference (&ip -> next,
                        MDL);
                }
            }
            /* Copy "client" to tmp */
            if (ip -> client) {
                tmp -> client = ip -> client;
                tmp -> client -> interface = tmp;
            }
            interface_dereference (&ip, MDL);
            break;
        }
        last = ip;
    }
    return 1;
}

isc_result_t dhclient_interface_startup_hook (struct interface_info *interface)
{
    struct interface_info *ip;
    struct client_state *client;

    /* This code needs some rethinking.   It doesn't test against
       a signal name, and it just kind of bulls into doing something
       that may or may not be appropriate. */

    if (interfaces) {
        interface_reference (&interface -> next, interfaces, MDL);
        interface_dereference (&interfaces, MDL);
    }
    interface_reference (&interfaces, interface, MDL);

    discover_interfaces (DISCOVER_UNCONFIGURED);

    for (ip = interfaces; ip; ip = ip -> next) {
        /* If interfaces were specified, don't configure
           interfaces that weren't specified! */
        if (ip -> flags & INTERFACE_RUNNING ||
            (ip -> flags & (INTERFACE_REQUESTED |
                            INTERFACE_AUTOMATIC)) !=
            INTERFACE_REQUESTED)
            continue;
        script_init (ip -> client,
            "PREINIT", (struct string_list *)0);
        if (ip -> client -> alias)
            script_write_params (ip -> client, "alias_",
                ip -> client -> alias);
        script_go (ip -> client);
    }

    discover_interfaces (interfaces_requested != 0
        ? DISCOVER_REQUESTED
        : DISCOVER_RUNNING);

    for (ip = interfaces; ip; ip = ip -> next) {
        if (ip -> flags & INTERFACE_RUNNING)
            continue;
        ip -> flags |= INTERFACE_RUNNING;
        for (client = ip->client ; client ; client = client->next) {
            client->state = S_INIT;
            state_reboot(client);
        }
    }
    return ISC_R_SUCCESS;
}

/* The client should never receive a relay agent information option,
   so if it does, log it and discard it. */

int parse_agent_information_option (packet, len, data)
    struct packet *packet;
    int len;
    u_int8_t *data;
{
    return 1;
}

/* The client never sends relay agent information options. */

unsigned cons_agent_information_options (cfg_options, outpacket,
    agentix, length)
    struct option_state *cfg_options;
    struct dhcp_packet *outpacket;
    unsigned agentix;
    unsigned length;
{
    return length;
}

static void shutdown_exit (void *foo)
{
    exit (0);
}

isc_result_t dhcp_set_control_state (control_object_state_t oldstate,
    control_object_state_t newstate)
{
    struct interface_info *ip;
    struct client_state *client;
    struct timeval tv;

    /* Do the right thing for each interface. */
    for (ip = interfaces; ip; ip = ip -> next) {
        for (client = ip -> client; client; client = client -> next) {
            switch (newstate) {
            case server_startup:
                return ISC_R_SUCCESS;

            case server_running:
                return ISC_R_SUCCESS;

            case server_shutdown:
                if (client -> active &&
                    client -> active -> expiry > cur_time) {
                    if (client -> config -> do_forward_update)
                        client_dns_update(client, 0, 0,
                            &client->active->address);
                    do_release (client);
                }
                break;

            case server_hibernate:
                state_stop (client);
                break;

            case server_awaken:
                state_reboot (client);
                break;
            }
        }
    }

    if (newstate == server_shutdown) {
        tv.tv_sec = cur_tv.tv_sec;
        tv.tv_usec = cur_tv.tv_usec + 1;
        add_timeout(&tv, shutdown_exit, 0, 0, 0);
    }
    return ISC_R_SUCCESS;
}

/* Schedule updates to retry occasionally until it no longer times out.
*/
void
dhclient_schedule_updates(struct client_state *client, struct iaddr *addr,
    int offset)
{
    struct dns_update_state *ustate;
    struct timeval tv;

    if (!client->config->do_forward_update)
        return;

    ustate = dmalloc(sizeof(*ustate), MDL);

    if (ustate != NULL) {
        ustate->client = client;
        ustate->address = *addr;
        ustate->dns_update_timeout = 1;

        tv.tv_sec = cur_tv.tv_sec + offset;
        tv.tv_usec = cur_tv.tv_usec;
        add_timeout(&tv, client_dns_update_timeout,
            ustate, NULL, NULL);
    } else {
        log_error("Unable to allocate dns update state for %s.",
            piaddr(*addr));
    }
}

/* Called after a timeout if the DNS update failed on the previous try.
   Retries the update, and if it times out, schedules a retry after
   ten times as long of a wait. */

void client_dns_update_timeout (void *cp)
{
    struct dns_update_state *ustate = cp;
    isc_result_t status = ISC_R_FAILURE;
    struct timeval tv;

    /* XXX: DNS TTL is a problem we need to solve properly.  Until
     * that time, 300 is a placeholder default for something that is
     * less insane than a value scaled by lease timeout.
     */
    if ((ustate->client->active != NULL) ||
        (ustate->client->active_lease != NULL))
        status = client_dns_update(ustate->client, 1, 300,
            &ustate->address);

    if (status == ISC_R_TIMEDOUT) {
        if (ustate->dns_update_timeout < 3600)
            ustate->dns_update_timeout *= 10;
        tv.tv_sec = cur_tv.tv_sec + ustate->dns_update_timeout;
        tv.tv_usec = cur_tv.tv_usec;
        add_timeout(&tv, client_dns_update_timeout,
            ustate, NULL, NULL);
    } else
        dfree(ustate, MDL);
}

/* See if we should do a DNS update, and if so, do it. */

isc_result_t client_dns_update (struct client_state *client, int addp,
    int ttl, struct iaddr *address)
{
    struct data_string ddns_fwd_name, ddns_dhcid, client_identifier;
    struct option_cache *oc;
    int ignorep;
    int result;
    isc_result_t rcode;

    /* If we didn't send an FQDN option, we certainly aren't going to
       be doing an update. */
    if (!client -> sent_options)
        return ISC_R_SUCCESS;

    /* If we don't have a lease, we can't do an update. */
    if ((client->active == NULL) && (client->active_lease == NULL))
        return ISC_R_SUCCESS;

    /* If we set the no client update flag, don't do the update. */
    if ((oc = lookup_option (&fqdn_universe, client -> sent_options,
                FQDN_NO_CLIENT_UPDATE)) &&
        evaluate_boolean_option_cache (&ignorep, (struct packet *)0,
            (struct lease *)0, client,
            client -> sent_options,
            (struct option_state *)0,
            &global_scope, oc, MDL))
        return ISC_R_SUCCESS;

    /* If we set the "server, please update" flag, or didn't set it
       to false, don't do the update. */
    if (!(oc = lookup_option (&fqdn_universe, client -> sent_options,
                FQDN_SERVER_UPDATE)) ||
        evaluate_boolean_option_cache (&ignorep, (struct packet *)0,
            (struct lease *)0, client,
            client -> sent_options,
            (struct option_state *)0,
            &global_scope, oc, MDL))
        return ISC_R_SUCCESS;

    /* If no FQDN option was supplied, don't do the update. */
    memset (&ddns_fwd_name, 0, sizeof ddns_fwd_name);
    if (!(oc = lookup_option (&fqdn_universe, client -> sent_options,
                FQDN_FQDN)) ||
        !evaluate_option_cache (&ddns_fwd_name, (struct packet *)0,
            (struct lease *)0, client,
            client -> sent_options,
            (struct option_state *)0,
            &global_scope, oc, MDL))
        return ISC_R_SUCCESS;

    /* If this is a DHCPv6 client update, make a dhcid string out of
     * the DUID.  If this is a DHCPv4 client update, choose either
     * the client identifier, if there is one, or the interface's
     * MAC address.
     */
    memset (&ddns_dhcid, 0, sizeof ddns_dhcid);

    result = 0;
    memset(&client_identifier, 0, sizeof(client_identifier));
    if (client->active_lease != NULL) {
        if (((oc =
                    lookup_option(&dhcpv6_universe, client->sent_options,
                        D6O_CLIENTID)) != NULL) &&
            evaluate_option_cache(&client_identifier, NULL, NULL,
                client, client->sent_options, NULL,
                &global_scope, oc, MDL)) {
            /* RFC4701 defines type '2' as being for the DUID
             * field.  We aren't using RFC4701 DHCID RR's yet,
             * but this is as good a value as any.
             */
            result = get_dhcid(&ddns_dhcid, 2,
                client_identifier.data,
                client_identifier.len);
            data_string_forget(&client_identifier, MDL);
        } else
            log_fatal("Impossible condition at %s:%d.", MDL);
    } else {
        if (((oc =
                    lookup_option(&dhcp_universe, client->sent_options,
                        DHO_DHCP_CLIENT_IDENTIFIER)) != NULL) &&
            evaluate_option_cache(&client_identifier, NULL, NULL,
                client, client->sent_options, NULL,
                &global_scope, oc, MDL)) {
            result = get_dhcid(&ddns_dhcid,
                DHO_DHCP_CLIENT_IDENTIFIER,
                client_identifier.data,
                client_identifier.len);
            data_string_forget(&client_identifier, MDL);
        } else
            result = get_dhcid(&ddns_dhcid, 0,
                client->interface->hw_address.hbuf,
                client->interface->hw_address.hlen);
    }
    if (!result) {
        data_string_forget(&ddns_fwd_name, MDL);
        return ISC_R_SUCCESS;
    }

    /* Start the resolver, if necessary. */
    if (!resolver_inited) {
        minires_ninit (&resolver_state);
        resolver_inited = 1;
        resolver_state.retrans = 1;
        resolver_state.retry = 1;
    }

    /*
     * Perform updates.
     */
    if (ddns_fwd_name.len && ddns_dhcid.len) {
        if (addp)
            rcode = ddns_update_fwd(&ddns_fwd_name, *address,
                &ddns_dhcid, ttl, 1, 1);
        else
            rcode = ddns_remove_fwd(&ddns_fwd_name, *address,
                &ddns_dhcid);
    } else
        rcode = ISC_R_FAILURE;

    data_string_forget (&ddns_fwd_name, MDL);
    data_string_forget (&ddns_dhcid, MDL);
    return rcode;
}

void
dhcpv4_client_assignments(void)
{
    struct servent *ent;

    if (path_dhclient_pid == NULL)
        path_dhclient_pid = _PATH_DHCLIENT_PID;
    if (path_dhclient_db == NULL)
        path_dhclient_db = _PATH_DHCLIENT_DB;

    /* Default to the DHCP/BOOTP port. */
    if (!local_port) {
        /* If we're faking a relay agent, and we're not using loopback,
           use the server port, not the client port. */
        if (mockup_relay && giaddr.s_addr != htonl (INADDR_LOOPBACK)) {
            local_port = htons(67);
        } else {
            ent = getservbyname ("dhcpc", "udp");
            if (!ent)
                local_port = htons (68);
            else
                local_port = ent -> s_port;
#ifndef __CYGWIN32__
            endservent ();
#endif
        }
    }

    /* If we're faking a relay agent, and we're not using loopback,
       we're using the server port, not the client port. */
    if (mockup_relay && giaddr.s_addr != htonl (INADDR_LOOPBACK)) {
        remote_port = local_port;
    } else
        remote_port = htons (ntohs (local_port) - 1);   /* XXX */
}

/*
 * The following routines are used to check that certain
 * strings are reasonable before we pass them to the scripts.
 * This avoids some problems with scripts treating the strings
 * as commands - see ticket 23722
 * The domain checking code should be done as part of assembling
 * the string but we are doing it here for now due to time
 * constraints.
 */

static int check_domain_name(const char *ptr, size_t len, int dots)
{
    const char *p;

    /* not empty or complete length not over 255 characters   */
    if ((len == 0) || (len > 256))
        return(-1);

    /* consists of [[:alnum:]-]+ labels separated by [.]      */
    /* a [_] is against RFC but seems to be "widely used"...  */
    for (p=ptr; (*p != 0) && (len-- > 0); p++) {
        if ((*p == '-') || (*p == '_')) {
            /* not allowed at begin or end of a label */
            if (((p - ptr) == 0) || (len == 0) || (p[1] == '.'))
                return(-1);
        } else if (*p == '.') {
            /* each label has to be 1-63 characters;
               we allow [.] at the end ('foo.bar.')   */
            size_t d = p - ptr;
            if ((d <= 0) || (d >= 64))
                return(-1);
            ptr = p + 1; /* jump to the next label    */
            if ((dots > 0) && (len > 0))
                dots--;
        } else if (isalnum((unsigned char)*p) == 0) {
            /* also numbers at the begin are fine     */
            return(-1);
        }
    }
    return(dots ? -1 : 0);
}

static int check_domain_name_list(const char *ptr, size_t len, int dots)
{
    const char *p;
    int ret = -1; /* at least one needed */

    if ((ptr == NULL) || (len == 0))
        return(-1);

    for (p=ptr; (*p != 0) && (len > 0); p++, len--) {
        if (*p != ' ')
            continue;
        if (p > ptr) {
            if (check_domain_name(ptr, p - ptr, dots) != 0)
                return(-1);
            ret = 0;
        }
        ptr = p + 1;
    }
    if (p > ptr)
        return(check_domain_name(ptr, p - ptr, dots));
    else
        return(ret);
}

static int check_option_values(struct universe *universe,
    unsigned int opt,
    const char *ptr,
    size_t len)
{
    if (ptr == NULL)
        return(-1);

    /* just reject options we want to protect, will be escaped anyway */
    if ((universe == NULL) || (universe == &dhcp_universe)) {
        switch(opt) {
        case DHO_DOMAIN_NAME:
#ifdef ACCEPT_LIST_IN_DOMAIN_NAME
            return check_domain_name_list(ptr, len, 0);
#else
            return check_domain_name(ptr, len, 0);
#endif
        case DHO_HOST_NAME:
        case DHO_NIS_DOMAIN:
        case DHO_NETBIOS_SCOPE:
            return check_domain_name(ptr, len, 0);
            break;
        case DHO_DOMAIN_SEARCH:
            return check_domain_name_list(ptr, len, 0);
            break;
        case DHO_ROOT_PATH:
            if (len == 0)
                return(-1);
            for (; (*ptr != 0) && (len-- > 0); ptr++) {
                if(!(isalnum((unsigned char)*ptr) ||
                        *ptr == '#'  || *ptr == '%' ||
                        *ptr == '+'  || *ptr == '-' ||
                        *ptr == '_'  || *ptr == ':' ||
                        *ptr == '.'  || *ptr == ',' ||
                        *ptr == '@'  || *ptr == '~' ||
                        *ptr == '\\' || *ptr == '/' ||
                        *ptr == '['  || *ptr == ']' ||
                        *ptr == '='  || *ptr == ' '))
                    return(-1);
            }
            return(0);
            break;
        }
    }

#ifdef DHCPv6
    if (universe == &dhcpv6_universe) {
        switch(opt) {
        case D6O_SIP_SERVERS_DNS:
        case D6O_DOMAIN_SEARCH:
        case D6O_NIS_DOMAIN_NAME:
        case D6O_NISP_DOMAIN_NAME:
            return check_domain_name_list(ptr, len, 0);
            break;
        }
    }
#endif

    return(0);
}

static void
add_reject(struct packet *packet) {

    struct iaddrmatchlist *list;

    list = dmalloc(sizeof(struct iaddrmatchlist), MDL);
    if (!list)
        log_fatal ("no memory for reject list!");

    /*
     * client_addr is misleading - it is set to source address in common
     * code.
     */
    list->match.addr = packet->client_addr;
    /* Set mask to indicate host address. */
    list->match.mask.len = list->match.addr.len;
    memset(list->match.mask.iabuf, 0xff, sizeof(list->match.mask.iabuf));

    /* Append to reject list for the source interface. */
    list->next = packet->interface->client->config->reject_list;
    packet->interface->client->config->reject_list = list;

    /*
     * We should inform user that we won't be accepting this server
     * anymore.
     */
    log_info("Server added to list of rejected servers.");
}
